(0) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
(1) DependencyPairsProof (EQUIVALENT transformation)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
(2) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ZEROS → CONS(0, n__zeros)
ZEROS → 01
U411(tt, V2) → U421(isNatIList(activate(V2)))
U411(tt, V2) → ISNATILIST(activate(V2))
U411(tt, V2) → ACTIVATE(V2)
U511(tt, V2) → U521(isNatList(activate(V2)))
U511(tt, V2) → ISNATLIST(activate(V2))
U511(tt, V2) → ACTIVATE(V2)
U611(tt, V2) → U621(isNatIList(activate(V2)))
U611(tt, V2) → ISNATILIST(activate(V2))
U611(tt, V2) → ACTIVATE(V2)
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
U711(tt, L, N) → ISNAT(activate(N))
U711(tt, L, N) → ACTIVATE(N)
U711(tt, L, N) → ACTIVATE(L)
U721(tt, L) → S(length(activate(L)))
U721(tt, L) → LENGTH(activate(L))
U721(tt, L) → ACTIVATE(L)
U811(tt) → NIL
U911(tt, IL, M, N) → U921(isNat(activate(M)), activate(IL), activate(M), activate(N))
U911(tt, IL, M, N) → ISNAT(activate(M))
U911(tt, IL, M, N) → ACTIVATE(M)
U911(tt, IL, M, N) → ACTIVATE(IL)
U911(tt, IL, M, N) → ACTIVATE(N)
U921(tt, IL, M, N) → U931(isNat(activate(N)), activate(IL), activate(M), activate(N))
U921(tt, IL, M, N) → ISNAT(activate(N))
U921(tt, IL, M, N) → ACTIVATE(N)
U921(tt, IL, M, N) → ACTIVATE(IL)
U921(tt, IL, M, N) → ACTIVATE(M)
U931(tt, IL, M, N) → CONS(activate(N), n__take(activate(M), activate(IL)))
U931(tt, IL, M, N) → ACTIVATE(N)
U931(tt, IL, M, N) → ACTIVATE(M)
U931(tt, IL, M, N) → ACTIVATE(IL)
ISNAT(n__length(V1)) → U111(isNatList(activate(V1)))
ISNAT(n__length(V1)) → ISNATLIST(activate(V1))
ISNAT(n__length(V1)) → ACTIVATE(V1)
ISNAT(n__s(V1)) → U211(isNat(activate(V1)))
ISNAT(n__s(V1)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ISNATILIST(V) → U311(isNatList(activate(V)))
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATILIST(V) → ACTIVATE(V)
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
LENGTH(nil) → 01
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
LENGTH(cons(N, L)) → ISNATLIST(activate(L))
LENGTH(cons(N, L)) → ACTIVATE(L)
TAKE(0, IL) → U811(isNatIList(IL))
TAKE(0, IL) → ISNATILIST(IL)
TAKE(s(M), cons(N, IL)) → U911(isNatIList(activate(IL)), activate(IL), M, N)
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
ACTIVATE(n__zeros) → ZEROS
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__0) → 01
ACTIVATE(n__length(X)) → LENGTH(activate(X))
ACTIVATE(n__length(X)) → ACTIVATE(X)
ACTIVATE(n__s(X)) → S(activate(X))
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → CONS(activate(X1), X2)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__nil) → NIL
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(3) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 18 less nodes.
(4) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__length(V1)) → ISNATLIST(activate(V1))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__length(X)) → LENGTH(activate(X))
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
U721(tt, L) → LENGTH(activate(L))
LENGTH(cons(N, L)) → ISNATLIST(activate(L))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ACTIVATE(n__length(X)) → ACTIVATE(X)
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
U611(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(V) → ACTIVATE(V)
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__length(V1)) → ACTIVATE(V1)
ISNAT(n__s(V1)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
U411(tt, V2) → ACTIVATE(V2)
U611(tt, V2) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
LENGTH(cons(N, L)) → ACTIVATE(L)
U721(tt, L) → ACTIVATE(L)
U711(tt, L, N) → ISNAT(activate(N))
U711(tt, L, N) → ACTIVATE(N)
U711(tt, L, N) → ACTIVATE(L)
U511(tt, V2) → ACTIVATE(V2)
TAKE(s(M), cons(N, IL)) → U911(isNatIList(activate(IL)), activate(IL), M, N)
U911(tt, IL, M, N) → U921(isNat(activate(M)), activate(IL), activate(M), activate(N))
U921(tt, IL, M, N) → U931(isNat(activate(N)), activate(IL), activate(M), activate(N))
U931(tt, IL, M, N) → ACTIVATE(N)
U931(tt, IL, M, N) → ACTIVATE(M)
U931(tt, IL, M, N) → ACTIVATE(IL)
U921(tt, IL, M, N) → ISNAT(activate(N))
U921(tt, IL, M, N) → ACTIVATE(N)
U921(tt, IL, M, N) → ACTIVATE(IL)
U921(tt, IL, M, N) → ACTIVATE(M)
U911(tt, IL, M, N) → ISNAT(activate(M))
U911(tt, IL, M, N) → ACTIVATE(M)
U911(tt, IL, M, N) → ACTIVATE(IL)
U911(tt, IL, M, N) → ACTIVATE(N)
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(5) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TAKE(s(M), cons(N, IL)) → U911(isNatIList(activate(IL)), activate(IL), M, N)
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( ISNAT(x1) ) = x1 + 2 |
POL( ISNATILIST(x1) ) = x1 + 2 |
POL( ISNATLIST(x1) ) = x1 + 2 |
POL( LENGTH(x1) ) = 2x1 + 2 |
POL( TAKE(x1, x2) ) = 2x1 + 2x2 + 2 |
POL( U411(x1, x2) ) = x2 + 2 |
POL( U511(x1, x2) ) = x2 + 2 |
POL( U611(x1, x2) ) = x2 + 2 |
POL( U711(x1, ..., x3) ) = 2x2 + x3 + 2 |
POL( U721(x1, x2) ) = 2x2 + 2 |
POL( U911(x1, ..., x4) ) = x1 + x2 + x3 + 2x4 |
POL( U921(x1, ..., x4) ) = x2 + x3 + 2x4 + 2 |
POL( U931(x1, ..., x4) ) = x2 + x3 + 2x4 + 2 |
POL( U71(x1, ..., x3) ) = 2x2 |
POL( U91(x1, ..., x4) ) = 2x2 + 2x3 + x4 |
POL( U92(x1, ..., x4) ) = 2x2 + 2x3 + x4 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x3 + x4 |
POL( cons(x1, x2) ) = x1 + x2 |
POL( isNat(x1) ) = 2x1 + 2 |
POL( take(x1, x2) ) = 2x1 + 2x2 |
POL( isNatList(x1) ) = x1 |
POL( isNatIList(x1) ) = x1 |
POL( U62(x1) ) = max{0, 2x1 - 2} |
POL( n__take(x1, x2) ) = 2x1 + 2x2 |
POL( n__length(x1) ) = 2x1 |
POL( n__cons(x1, x2) ) = x1 + x2 |
POL( ACTIVATE(x1) ) = x1 + 2 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
U11(tt) → tt
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
0 → n__0
nil → n__nil
(6) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__length(V1)) → ISNATLIST(activate(V1))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__length(X)) → LENGTH(activate(X))
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
U721(tt, L) → LENGTH(activate(L))
LENGTH(cons(N, L)) → ISNATLIST(activate(L))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ACTIVATE(n__length(X)) → ACTIVATE(X)
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
U611(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(V) → ACTIVATE(V)
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__length(V1)) → ACTIVATE(V1)
ISNAT(n__s(V1)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
U411(tt, V2) → ACTIVATE(V2)
U611(tt, V2) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
LENGTH(cons(N, L)) → ACTIVATE(L)
U721(tt, L) → ACTIVATE(L)
U711(tt, L, N) → ISNAT(activate(N))
U711(tt, L, N) → ACTIVATE(N)
U711(tt, L, N) → ACTIVATE(L)
U511(tt, V2) → ACTIVATE(V2)
U911(tt, IL, M, N) → U921(isNat(activate(M)), activate(IL), activate(M), activate(N))
U921(tt, IL, M, N) → U931(isNat(activate(N)), activate(IL), activate(M), activate(N))
U931(tt, IL, M, N) → ACTIVATE(N)
U931(tt, IL, M, N) → ACTIVATE(M)
U931(tt, IL, M, N) → ACTIVATE(IL)
U921(tt, IL, M, N) → ISNAT(activate(N))
U921(tt, IL, M, N) → ACTIVATE(N)
U921(tt, IL, M, N) → ACTIVATE(IL)
U921(tt, IL, M, N) → ACTIVATE(M)
U911(tt, IL, M, N) → ISNAT(activate(M))
U911(tt, IL, M, N) → ACTIVATE(M)
U911(tt, IL, M, N) → ACTIVATE(IL)
U911(tt, IL, M, N) → ACTIVATE(N)
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(7) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 13 less nodes.
(8) Obligation:
Q DP problem:
The TRS P consists of the following rules:
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__length(V1)) → ISNATLIST(activate(V1))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
ISNATILIST(V) → ACTIVATE(V)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__length(X)) → LENGTH(activate(X))
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
U721(tt, L) → LENGTH(activate(L))
LENGTH(cons(N, L)) → ISNATLIST(activate(L))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ACTIVATE(n__length(X)) → ACTIVATE(X)
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
U611(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__length(V1)) → ACTIVATE(V1)
ISNAT(n__s(V1)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
U411(tt, V2) → ACTIVATE(V2)
U611(tt, V2) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
LENGTH(cons(N, L)) → ACTIVATE(L)
U721(tt, L) → ACTIVATE(L)
U711(tt, L, N) → ISNAT(activate(N))
U711(tt, L, N) → ACTIVATE(N)
U711(tt, L, N) → ACTIVATE(L)
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
U511(tt, V2) → ACTIVATE(V2)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(9) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNAT(n__length(V1)) → ISNATLIST(activate(V1))
ACTIVATE(n__length(X)) → LENGTH(activate(X))
ACTIVATE(n__length(X)) → ACTIVATE(X)
ISNAT(n__length(V1)) → ACTIVATE(V1)
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( ISNATILIST(x1) ) = 2x1 |
POL( ISNATLIST(x1) ) = 2x1 |
POL( TAKE(x1, x2) ) = x1 + 2x2 |
POL( U411(x1, x2) ) = max{0, x1 + 2x2 - 2} |
POL( U511(x1, x2) ) = 2x2 |
POL( U611(x1, x2) ) = 2x2 |
POL( U711(x1, ..., x3) ) = 2x2 + 2x3 |
POL( U721(x1, x2) ) = max{0, x1 + 2x2 - 2} |
POL( U41(x1, x2) ) = max{0, x1 + x2 - 1} |
POL( U71(x1, ..., x3) ) = x2 + x3 + 2 |
POL( U72(x1, x2) ) = x2 + 2 |
POL( U91(x1, ..., x4) ) = 2x2 + 2x3 + 2x4 |
POL( U92(x1, ..., x4) ) = 2x2 + 2x3 + 2x4 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x3 + 2x4 |
POL( cons(x1, x2) ) = x1 + x2 |
POL( length(x1) ) = x1 + 2 |
POL( take(x1, x2) ) = 2x1 + 2x2 |
POL( isNatList(x1) ) = x1 |
POL( isNatIList(x1) ) = x1 + 1 |
POL( U62(x1) ) = max{0, 2x1 - 2} |
POL( n__take(x1, x2) ) = 2x1 + 2x2 |
POL( n__length(x1) ) = x1 + 2 |
POL( n__cons(x1, x2) ) = x1 + x2 |
POL( U81(x1) ) = max{0, 2x1 - 2} |
POL( ACTIVATE(x1) ) = 2x1 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
U11(tt) → tt
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
0 → n__0
nil → n__nil
(10) Obligation:
Q DP problem:
The TRS P consists of the following rules:
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
ISNATILIST(V) → ACTIVATE(V)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
U721(tt, L) → LENGTH(activate(L))
LENGTH(cons(N, L)) → ISNATLIST(activate(L))
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
U611(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
U411(tt, V2) → ACTIVATE(V2)
U611(tt, V2) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
LENGTH(cons(N, L)) → ACTIVATE(L)
U721(tt, L) → ACTIVATE(L)
U711(tt, L, N) → ISNAT(activate(N))
U711(tt, L, N) → ACTIVATE(N)
U711(tt, L, N) → ACTIVATE(L)
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
U511(tt, V2) → ACTIVATE(V2)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(11) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 6 less nodes.
(12) Complex Obligation (AND)
(13) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → ACTIVATE(V)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
U411(tt, V2) → ACTIVATE(V2)
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
U611(tt, V2) → ISNATILIST(activate(V2))
U611(tt, V2) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
U511(tt, V2) → ACTIVATE(V2)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(14) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNAT(n__s(V1)) → ACTIVATE(V1)
ACTIVATE(n__take(X1, X2)) → TAKE(activate(X1), activate(X2))
ISNATILIST(V) → ACTIVATE(V)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__take(X1, X2)) → ACTIVATE(X2)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATILIST(n__cons(V1, V2)) → ACTIVATE(V2)
U411(tt, V2) → ACTIVATE(V2)
TAKE(s(M), cons(N, IL)) → ACTIVATE(IL)
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__cons(V1, V2)) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → U611(isNat(activate(V1)), activate(V2))
U611(tt, V2) → ISNATILIST(activate(V2))
U611(tt, V2) → ACTIVATE(V2)
ISNATLIST(n__take(V1, V2)) → ISNAT(activate(V1))
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V1)
ISNATLIST(n__take(V1, V2)) → ACTIVATE(V2)
U511(tt, V2) → ACTIVATE(V2)
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( ISNAT(x1) ) = x1 + 1 |
POL( ISNATILIST(x1) ) = 2x1 + 1 |
POL( ISNATLIST(x1) ) = 2x1 + 1 |
POL( TAKE(x1, x2) ) = 2x1 + 2x2 + 1 |
POL( U411(x1, x2) ) = 2x2 + 1 |
POL( U511(x1, x2) ) = 2x2 + 1 |
POL( U611(x1, x2) ) = 2x2 + 2 |
POL( U71(x1, ..., x3) ) = max{0, -2} |
POL( U72(x1, x2) ) = max{0, -2} |
POL( U91(x1, ..., x4) ) = x2 + x3 + 2x4 + 2 |
POL( U92(x1, ..., x4) ) = x2 + x3 + 2x4 + 2 |
POL( U93(x1, ..., x4) ) = x2 + x3 + 2x4 + 2 |
POL( cons(x1, x2) ) = 2x1 + x2 |
POL( isNat(x1) ) = max{0, -2} |
POL( take(x1, x2) ) = x1 + x2 + 2 |
POL( U11(x1) ) = max{0, -2} |
POL( isNatList(x1) ) = 2x1 + 2 |
POL( isNatIList(x1) ) = 2 |
POL( n__take(x1, x2) ) = x1 + x2 + 2 |
POL( n__cons(x1, x2) ) = 2x1 + x2 |
POL( ACTIVATE(x1) ) = 2x1 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
0 → n__0
nil → n__nil
(15) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(V) → ISNATLIST(activate(V))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ISNAT(activate(V1))
TAKE(0, IL) → ISNATILIST(IL)
ACTIVATE(n__s(X)) → ACTIVATE(X)
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(V1, V2)) → ISNAT(activate(V1))
TAKE(s(M), cons(N, IL)) → ISNATILIST(activate(IL))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(16) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 4 SCCs with 5 less nodes.
(17) Complex Obligation (AND)
(18) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__s(X)) → ACTIVATE(X)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(19) UsableRulesProof (EQUIVALENT transformation)
We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.
(20) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__s(X)) → ACTIVATE(X)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(21) QDPSizeChangeProof (EQUIVALENT transformation)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.
From the DPs we obtained the following set of size-change graphs:
- ACTIVATE(n__cons(X1, X2)) → ACTIVATE(X1)
The graph contains the following edges 1 > 1
- ACTIVATE(n__s(X)) → ACTIVATE(X)
The graph contains the following edges 1 > 1
(22) YES
(23) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNAT(n__s(V1)) → ISNAT(activate(V1))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(24) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNAT(n__s(V1)) → ISNAT(activate(V1))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]:
POL(ISNAT(x1)) = | 3A | + | 1A | · | x1 |
POL(n__s(x1)) = | 3A | + | 1A | · | x1 |
POL(activate(x1)) = | 1A | + | 0A | · | x1 |
POL(n__take(x1, x2)) = | 3A | + | 1A | · | x1 | + | 0A | · | x2 |
POL(take(x1, x2)) = | 3A | + | 1A | · | x1 | + | 0A | · | x2 |
POL(n__length(x1)) = | 4A | + | 2A | · | x1 |
POL(length(x1)) = | 4A | + | 2A | · | x1 |
POL(n__cons(x1, x2)) = | -I | + | -I | · | x1 | + | 1A | · | x2 |
POL(cons(x1, x2)) = | -I | + | -I | · | x1 | + | 1A | · | x2 |
POL(U71(x1, x2, x3)) = | 4A | + | 3A | · | x1 | + | 3A | · | x2 | + | -I | · | x3 |
POL(isNatList(x1)) = | 1A | + | 0A | · | x1 |
POL(U51(x1, x2)) = | 1A | + | -I | · | x1 | + | 0A | · | x2 |
POL(isNat(x1)) = | 2A | + | -I | · | x1 |
POL(U11(x1)) = | 2A | + | -I | · | x1 |
POL(U61(x1, x2)) = | 3A | + | -I | · | x1 | + | 0A | · | x2 |
POL(U21(x1)) = | 2A | + | -I | · | x1 |
POL(U62(x1)) = | 0A | + | 1A | · | x1 |
POL(isNatIList(x1)) = | 2A | + | -I | · | x1 |
POL(U31(x1)) = | 2A | + | -I | · | x1 |
POL(U41(x1, x2)) = | 2A | + | 0A | · | x1 | + | -I | · | x2 |
POL(U42(x1)) = | 2A | + | -I | · | x1 |
POL(U52(x1)) = | 0A | + | 0A | · | x1 |
POL(U72(x1, x2)) = | 5A | + | -I | · | x1 | + | 3A | · | x2 |
POL(U81(x1)) = | 5A | + | -I | · | x1 |
POL(U91(x1, x2, x3, x4)) = | -I | + | 2A | · | x1 | + | 1A | · | x2 | + | 2A | · | x3 | + | -I | · | x4 |
POL(U92(x1, x2, x3, x4)) = | 3A | + | 2A | · | x1 | + | 1A | · | x2 | + | 2A | · | x3 | + | -I | · | x4 |
POL(U93(x1, x2, x3, x4)) = | 2A | + | 2A | · | x1 | + | 1A | · | x2 | + | 2A | · | x3 | + | -I | · | x4 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
0 → n__0
nil → n__nil
(25) Obligation:
Q DP problem:
P is empty.
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(26) PisEmptyProof (EQUIVALENT transformation)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
(27) YES
(28) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, V2) → ISNATLIST(activate(V2))
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(29) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U511(
tt,
V2) →
ISNATLIST(
activate(
V2)) at position [0] we obtained the following new rules [LPAR04]:
U511(tt, n__zeros) → ISNATLIST(zeros) → U511(tt, n__zeros) → ISNATLIST(zeros)
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1))) → U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__0) → ISNATLIST(0) → U511(tt, n__0) → ISNATLIST(0)
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0))) → U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0))) → U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1)) → U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
U511(tt, n__nil) → ISNATLIST(nil) → U511(tt, n__nil) → ISNATLIST(nil)
U511(tt, x0) → ISNATLIST(x0) → U511(tt, x0) → ISNATLIST(x0)
(30) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(V1, V2)) → U511(isNat(activate(V1)), activate(V2))
U511(tt, n__zeros) → ISNATLIST(zeros)
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__0) → ISNATLIST(0)
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
U511(tt, n__nil) → ISNATLIST(nil)
U511(tt, x0) → ISNATLIST(x0)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(31) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATLIST(
n__cons(
V1,
V2)) →
U511(
isNat(
activate(
V1)),
activate(
V2)) at position [0] we obtained the following new rules [LPAR04]:
ISNATLIST(n__cons(n__zeros, y1)) → U511(isNat(zeros), activate(y1)) → ISNATLIST(n__cons(n__zeros, y1)) → U511(isNat(zeros), activate(y1))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1)) → ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1)) → ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1)) → ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1)) → ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1)) → ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1)) → ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1)) → ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
(32) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__zeros) → ISNATLIST(zeros)
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__0) → ISNATLIST(0)
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
U511(tt, n__nil) → ISNATLIST(nil)
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__zeros, y1)) → U511(isNat(zeros), activate(y1))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(33) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U511(
tt,
n__zeros) →
ISNATLIST(
zeros) at position [0] we obtained the following new rules [LPAR04]:
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros)) → U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
U511(tt, n__zeros) → ISNATLIST(n__zeros) → U511(tt, n__zeros) → ISNATLIST(n__zeros)
(34) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__0) → ISNATLIST(0)
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
U511(tt, n__nil) → ISNATLIST(nil)
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__zeros, y1)) → U511(isNat(zeros), activate(y1))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
U511(tt, n__zeros) → ISNATLIST(n__zeros)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(35) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(36) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__zeros, y1)) → U511(isNat(zeros), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__0) → ISNATLIST(0)
ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__nil) → ISNATLIST(nil)
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(37) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATLIST(
n__cons(
n__zeros,
y1)) →
U511(
isNat(
zeros),
activate(
y1)) at position [0] we obtained the following new rules [LPAR04]:
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0)) → ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__zeros), activate(y0)) → ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__zeros), activate(y0))
(38) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__0) → ISNATLIST(0)
ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__nil) → ISNATLIST(nil)
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__zeros), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(39) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(40) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__0, y1)) → U511(isNat(0), activate(y1))
U511(tt, n__0) → ISNATLIST(0)
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, n__nil) → ISNATLIST(nil)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(41) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATLIST(
n__cons(
n__0,
y1)) →
U511(
isNat(
0),
activate(
y1)) at position [0] we obtained the following new rules [LPAR04]:
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0)) → ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
(42) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__0) → ISNATLIST(0)
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, n__nil) → ISNATLIST(nil)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(43) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U511(
tt,
n__0) →
ISNATLIST(
0) at position [0] we obtained the following new rules [LPAR04]:
U511(tt, n__0) → ISNATLIST(n__0) → U511(tt, n__0) → ISNATLIST(n__0)
(44) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, n__nil) → ISNATLIST(nil)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__0) → ISNATLIST(n__0)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(45) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(46) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__nil) → ISNATLIST(nil)
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(47) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U511(
tt,
n__nil) →
ISNATLIST(
nil) at position [0] we obtained the following new rules [LPAR04]:
U511(tt, n__nil) → ISNATLIST(n__nil) → U511(tt, n__nil) → ISNATLIST(n__nil)
(48) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__nil) → ISNATLIST(n__nil)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(49) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(50) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__nil, y1)) → U511(isNat(nil), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(51) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATLIST(
n__cons(
n__nil,
y1)) →
U511(
isNat(
nil),
activate(
y1)) at position [0] we obtained the following new rules [LPAR04]:
ISNATLIST(n__cons(n__nil, y0)) → U511(isNat(n__nil), activate(y0)) → ISNATLIST(n__cons(n__nil, y0)) → U511(isNat(n__nil), activate(y0))
(52) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
ISNATLIST(n__cons(n__nil, y0)) → U511(isNat(n__nil), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(53) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(54) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(55) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U511(
tt,
n__zeros) →
ISNATLIST(
cons(
0,
n__zeros)) at position [0] we obtained the following new rules [LPAR04]:
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros)) → U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros)) → U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros))
(56) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(57) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATLIST(
n__cons(
n__zeros,
y0)) →
U511(
isNat(
cons(
0,
n__zeros)),
activate(
y0)) at position [0] we obtained the following new rules [LPAR04]:
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__cons(0, n__zeros)), activate(y0)) → ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(n__0, n__zeros)), activate(y0)) → ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(n__0, n__zeros)), activate(y0))
(58) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__cons(0, n__zeros)), activate(y0))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(n__0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(59) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(60) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(cons(n__0, n__zeros)), activate(y0))
U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(61) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATLIST(
n__cons(
n__zeros,
y0)) →
U511(
isNat(
cons(
n__0,
n__zeros)),
activate(
y0)) at position [0] we obtained the following new rules [LPAR04]:
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__cons(n__0, n__zeros)), activate(y0)) → ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__cons(n__0, n__zeros)), activate(y0))
(62) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros))
ISNATLIST(n__cons(n__zeros, y0)) → U511(isNat(n__cons(n__0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(63) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(64) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(65) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U511(
tt,
n__zeros) →
ISNATLIST(
cons(
n__0,
n__zeros)) at position [0] we obtained the following new rules [LPAR04]:
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros)) → U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
(66) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(67) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATLIST(n__cons(n__take(x0, x1), y1)) → U511(isNat(take(activate(x0), activate(x1))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U511(x1, x2) ) = 2x1 + 2x2 |
POL( ISNATLIST(x1) ) = 2x1 + 2 |
POL( U61(x1, x2) ) = x1 + 2 |
POL( U71(x1, ..., x3) ) = max{0, x1 - 2} |
POL( U72(x1, x2) ) = max{0, x1 - 1} |
POL( U91(x1, ..., x4) ) = x2 + x4 + 2 |
POL( U92(x1, ..., x4) ) = x2 + x4 + 2 |
POL( U93(x1, ..., x4) ) = x2 + x4 + 2 |
POL( cons(x1, x2) ) = x1 + x2 |
POL( take(x1, x2) ) = x2 + 2 |
POL( isNatList(x1) ) = 2x1 + 2 |
POL( isNatIList(x1) ) = 2 |
POL( n__take(x1, x2) ) = x2 + 2 |
POL( n__length(x1) ) = 2x1 |
POL( n__cons(x1, x2) ) = x1 + x2 |
POL( U81(x1) ) = max{0, x1 - 1} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(68) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(69) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATLIST(n__cons(n__length(x0), y1)) → U511(isNat(length(activate(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U511(x1, x2) ) = 2x2 + 1 |
POL( ISNATLIST(x1) ) = 2x1 + 1 |
POL( U51(x1, x2) ) = max{0, 2x1 - 1} |
POL( U71(x1, ..., x3) ) = max{0, x1 + 2x3 - 1} |
POL( U72(x1, x2) ) = max{0, x1 - 1} |
POL( U91(x1, ..., x4) ) = max{0, x1 + x2 + 2x4 - 1} |
POL( U92(x1, ..., x4) ) = x2 + 2x4 |
POL( U93(x1, ..., x4) ) = x2 + 2x4 |
POL( cons(x1, x2) ) = 2x1 + x2 |
POL( length(x1) ) = 2x1 + 1 |
POL( isNatList(x1) ) = 2x1 + 2 |
POL( isNat(x1) ) = x1 + 1 |
POL( isNatIList(x1) ) = 1 |
POL( U62(x1) ) = max{0, 2x1 - 1} |
POL( n__take(x1, x2) ) = x2 |
POL( n__length(x1) ) = 2x1 + 1 |
POL( n__cons(x1, x2) ) = 2x1 + x2 |
POL( U81(x1) ) = max{0, 2x1 - 2} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(70) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(71) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATLIST(n__cons(n__s(x0), y1)) → U511(isNat(s(activate(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U511(x1, x2) ) = x1 + x2 + 2 |
POL( ISNATLIST(x1) ) = x1 + 2 |
POL( U41(x1, x2) ) = max{0, -2} |
POL( U51(x1, x2) ) = max{0, -2} |
POL( U71(x1, ..., x3) ) = 2 |
POL( U91(x1, ..., x4) ) = 2x2 + 2x4 |
POL( U92(x1, ..., x4) ) = 2x2 + 2x4 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x4 |
POL( cons(x1, x2) ) = 2x1 + x2 |
POL( take(x1, x2) ) = 2x2 |
POL( U21(x1) ) = max{0, -2} |
POL( isNat(x1) ) = max{0, 2x1 - 1} |
POL( U31(x1) ) = max{0, -1} |
POL( isNatIList(x1) ) = 0 |
POL( n__take(x1, x2) ) = 2x2 |
POL( n__cons(x1, x2) ) = 2x1 + x2 |
POL( U81(x1) ) = max{0, -2} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
cons(X1, X2) → n__cons(X1, X2)
0 → n__0
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(72) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(73) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U511(tt, n__length(x0)) → ISNATLIST(length(activate(x0)))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U511(x1, x2) ) = max{0, 2x1 + 2x2 - 2} |
POL( ISNATLIST(x1) ) = x1 + 2 |
POL( U51(x1, x2) ) = 2x2 + 2 |
POL( U71(x1, ..., x3) ) = max{0, x1 - 1} |
POL( U72(x1, x2) ) = max{0, -2} |
POL( U91(x1, ..., x4) ) = 2x2 + 2x4 |
POL( U92(x1, ..., x4) ) = 2x2 + 2x4 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x4 |
POL( cons(x1, x2) ) = 2x1 + 2x2 |
POL( length(x1) ) = 2x1 + 1 |
POL( s(x1) ) = max{0, -2} |
POL( isNatList(x1) ) = x1 + 2 |
POL( isNat(x1) ) = x1 + 2 |
POL( U42(x1) ) = max{0, 2x1 - 2} |
POL( isNatIList(x1) ) = 2 |
POL( n__take(x1, x2) ) = x2 |
POL( n__length(x1) ) = 2x1 + 1 |
POL( n__cons(x1, x2) ) = 2x1 + 2x2 |
POL( U81(x1) ) = max{0, -1} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(74) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(75) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U511(tt, n__s(x0)) → ISNATLIST(s(activate(x0)))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U511(x1, x2) ) = x1 + 2x2 |
POL( ISNATLIST(x1) ) = x1 + 2 |
POL( U51(x1, x2) ) = x1 + 2x2 |
POL( U61(x1, x2) ) = x1 + 2x2 |
POL( U71(x1, ..., x3) ) = 2 |
POL( U91(x1, ..., x4) ) = 2x2 |
POL( U92(x1, ..., x4) ) = 2x2 |
POL( U93(x1, ..., x4) ) = 2x2 |
POL( cons(x1, x2) ) = 2x2 |
POL( isNatList(x1) ) = 2x1 + 2 |
POL( isNatIList(x1) ) = 2 |
POL( U62(x1) ) = max{0, 2x1 - 2} |
POL( n__take(x1, x2) ) = x2 |
POL( n__cons(x1, x2) ) = 2x2 |
POL( U81(x1) ) = max{0, -2} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
length(nil) → 0
length(X) → n__length(X)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(76) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(77) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U511(tt, n__take(x0, x1)) → ISNATLIST(take(activate(x0), activate(x1)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]:
POL(U511(x1, x2)) = | -I | + | 0A | · | x1 | + | 1A | · | x2 |
POL(n__take(x1, x2)) = | 5A | + | 2A | · | x1 | + | 2A | · | x2 |
POL(ISNATLIST(x1)) = | 5A | + | 0A | · | x1 |
POL(take(x1, x2)) = | 5A | + | 2A | · | x1 | + | 2A | · | x2 |
POL(activate(x1)) = | 2A | + | 0A | · | x1 |
POL(n__cons(x1, x2)) = | 2A | + | 0A | · | x1 | + | 1A | · | x2 |
POL(cons(x1, x2)) = | 2A | + | 0A | · | x1 | + | 1A | · | x2 |
POL(isNat(x1)) = | 5A | + | -I | · | x1 |
POL(n__length(x1)) = | 4A | + | 0A | · | x1 |
POL(length(x1)) = | 4A | + | 0A | · | x1 |
POL(n__s(x1)) = | 4A | + | 1A | · | x1 |
POL(U81(x1)) = | 5A | + | -I | · | x1 |
POL(isNatIList(x1)) = | 5A | + | 0A | · | x1 |
POL(U91(x1, x2, x3, x4)) = | 5A | + | 1A | · | x1 | + | 3A | · | x2 | + | 3A | · | x3 | + | 0A | · | x4 |
POL(U11(x1)) = | 5A | + | -I | · | x1 |
POL(isNatList(x1)) = | 3A | + | 0A | · | x1 |
POL(U21(x1)) = | 5A | + | -I | · | x1 |
POL(U71(x1, x2, x3)) = | 3A | + | 0A | · | x1 | + | 1A | · | x2 | + | -I | · | x3 |
POL(U51(x1, x2)) = | 3A | + | -I | · | x1 | + | 0A | · | x2 |
POL(U61(x1, x2)) = | 1A | + | 0A | · | x1 | + | -I | · | x2 |
POL(U62(x1)) = | 5A | + | -I | · | x1 |
POL(U31(x1)) = | 5A | + | -I | · | x1 |
POL(U41(x1, x2)) = | 5A | + | -I | · | x1 | + | -I | · | x2 |
POL(U42(x1)) = | 5A | + | -I | · | x1 |
POL(U52(x1)) = | 3A | + | 0A | · | x1 |
POL(U72(x1, x2)) = | 5A | + | -I | · | x1 | + | 1A | · | x2 |
POL(U92(x1, x2, x3, x4)) = | -I | + | 1A | · | x1 | + | 3A | · | x2 | + | 3A | · | x3 | + | 0A | · | x4 |
POL(U93(x1, x2, x3, x4)) = | 4A | + | 1A | · | x1 | + | 3A | · | x2 | + | 3A | · | x3 | + | 0A | · | x4 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(78) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(79) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATLIST(n__cons(n__cons(x0, x1), y1)) → U511(isNat(cons(activate(x0), x1)), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] to (N^2, +, *, >=, >) :
POL(U511(x1, x2)) = | 0 | + | | · | x1 | + | | · | x2 |
POL(n__cons(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(ISNATLIST(x1)) = | 0 | + | | · | x1 |
POL(cons(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(activate(x1)) = | | + | | · | x1 |
POL(n__take(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(take(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(n__length(x1)) = | | + | | · | x1 |
POL(isNatList(x1)) = | | + | | · | x1 |
POL(U71(x1, x2, x3)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 |
POL(U51(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U61(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(isNatIList(x1)) = | | + | | · | x1 |
POL(U41(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U72(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U91(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
POL(U92(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
POL(U93(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(80) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U511(tt, n__cons(x0, x1)) → ISNATLIST(cons(activate(x0), x1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(n__cons(x0, y1)) → U511(isNat(x0), activate(y1))
U511(tt, n__zeros) → ISNATLIST(n__cons(0, n__zeros))
ISNATLIST(n__cons(n__0, y0)) → U511(isNat(n__0), activate(y0))
U511(tt, n__zeros) → ISNATLIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(81) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(V1, V2)) → U411(isNat(activate(V1)), activate(V2))
U411(tt, V2) → ISNATILIST(activate(V2))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(82) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATILIST(
n__cons(
V1,
V2)) →
U411(
isNat(
activate(
V1)),
activate(
V2)) at position [0] we obtained the following new rules [LPAR04]:
ISNATILIST(n__cons(n__zeros, y1)) → U411(isNat(zeros), activate(y1)) → ISNATILIST(n__cons(n__zeros, y1)) → U411(isNat(zeros), activate(y1))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1)) → ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1)) → ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1)) → ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1)) → ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1)) → ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1)) → ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1)) → ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
(83) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, V2) → ISNATILIST(activate(V2))
ISNATILIST(n__cons(n__zeros, y1)) → U411(isNat(zeros), activate(y1))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(84) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U411(
tt,
V2) →
ISNATILIST(
activate(
V2)) at position [0] we obtained the following new rules [LPAR04]:
U411(tt, n__zeros) → ISNATILIST(zeros) → U411(tt, n__zeros) → ISNATILIST(zeros)
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1))) → U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__0) → ISNATILIST(0) → U411(tt, n__0) → ISNATILIST(0)
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0))) → U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0))) → U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1)) → U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
U411(tt, n__nil) → ISNATILIST(nil) → U411(tt, n__nil) → ISNATILIST(nil)
U411(tt, x0) → ISNATILIST(x0) → U411(tt, x0) → ISNATILIST(x0)
(85) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__zeros, y1)) → U411(isNat(zeros), activate(y1))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(zeros)
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__0) → ISNATILIST(0)
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
U411(tt, n__nil) → ISNATILIST(nil)
U411(tt, x0) → ISNATILIST(x0)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(86) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATILIST(
n__cons(
n__zeros,
y1)) →
U411(
isNat(
zeros),
activate(
y1)) at position [0] we obtained the following new rules [LPAR04]:
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0)) → ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__zeros), activate(y0)) → ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__zeros), activate(y0))
(87) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(zeros)
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__0) → ISNATILIST(0)
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
U411(tt, n__nil) → ISNATILIST(nil)
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__zeros), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(88) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(89) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__zeros) → ISNATILIST(zeros)
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
U411(tt, n__0) → ISNATILIST(0)
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, n__nil) → ISNATILIST(nil)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(90) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U411(
tt,
n__zeros) →
ISNATILIST(
zeros) at position [0] we obtained the following new rules [LPAR04]:
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros)) → U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__zeros) → U411(tt, n__zeros) → ISNATILIST(n__zeros)
(91) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
U411(tt, n__0) → ISNATILIST(0)
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, n__nil) → ISNATILIST(nil)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__zeros)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(92) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(93) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__0) → ISNATILIST(0)
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__nil) → ISNATILIST(nil)
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(94) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U411(
tt,
n__0) →
ISNATILIST(
0) at position [0] we obtained the following new rules [LPAR04]:
U411(tt, n__0) → ISNATILIST(n__0) → U411(tt, n__0) → ISNATILIST(n__0)
(95) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__nil) → ISNATILIST(nil)
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
U411(tt, n__0) → ISNATILIST(n__0)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(96) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(97) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__0, y1)) → U411(isNat(0), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__nil) → ISNATILIST(nil)
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(98) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATILIST(
n__cons(
n__0,
y1)) →
U411(
isNat(
0),
activate(
y1)) at position [0] we obtained the following new rules [LPAR04]:
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0)) → ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
(99) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__nil) → ISNATILIST(nil)
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(100) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U411(
tt,
n__nil) →
ISNATILIST(
nil) at position [0] we obtained the following new rules [LPAR04]:
U411(tt, n__nil) → ISNATILIST(n__nil) → U411(tt, n__nil) → ISNATILIST(n__nil)
(101) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__nil) → ISNATILIST(n__nil)
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(102) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(103) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__nil, y1)) → U411(isNat(nil), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(104) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATILIST(
n__cons(
n__nil,
y1)) →
U411(
isNat(
nil),
activate(
y1)) at position [0] we obtained the following new rules [LPAR04]:
ISNATILIST(n__cons(n__nil, y0)) → U411(isNat(n__nil), activate(y0)) → ISNATILIST(n__cons(n__nil, y0)) → U411(isNat(n__nil), activate(y0))
(105) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
ISNATILIST(n__cons(n__nil, y0)) → U411(isNat(n__nil), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(106) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(107) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(0, n__zeros)), activate(y0))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(108) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATILIST(
n__cons(
n__zeros,
y0)) →
U411(
isNat(
cons(
0,
n__zeros)),
activate(
y0)) at position [0] we obtained the following new rules [LPAR04]:
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__cons(0, n__zeros)), activate(y0)) → ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(n__0, n__zeros)), activate(y0)) → ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(n__0, n__zeros)), activate(y0))
(109) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__cons(0, n__zeros)), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(n__0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(110) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(111) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, n__zeros) → ISNATILIST(cons(0, n__zeros))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(n__0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(112) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U411(
tt,
n__zeros) →
ISNATILIST(
cons(
0,
n__zeros)) at position [0] we obtained the following new rules [LPAR04]:
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros)) → U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(cons(n__0, n__zeros)) → U411(tt, n__zeros) → ISNATILIST(cons(n__0, n__zeros))
(113) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(cons(n__0, n__zeros)), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(114) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
ISNATILIST(
n__cons(
n__zeros,
y0)) →
U411(
isNat(
cons(
n__0,
n__zeros)),
activate(
y0)) at position [0] we obtained the following new rules [LPAR04]:
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__cons(n__0, n__zeros)), activate(y0)) → ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__cons(n__0, n__zeros)), activate(y0))
(115) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(cons(n__0, n__zeros))
ISNATILIST(n__cons(n__zeros, y0)) → U411(isNat(n__cons(n__0, n__zeros)), activate(y0))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(116) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(117) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(118) TransformationProof (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
U411(
tt,
n__zeros) →
ISNATILIST(
cons(
n__0,
n__zeros)) at position [0] we obtained the following new rules [LPAR04]:
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros)) → U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
(119) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(120) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATILIST(n__cons(n__length(x0), y1)) → U411(isNat(length(activate(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U411(x1, x2) ) = x2 + 1 |
POL( ISNATILIST(x1) ) = x1 + 1 |
POL( U51(x1, x2) ) = x1 + x2 |
POL( U61(x1, x2) ) = max{0, 2x1 + x2 - 2} |
POL( U71(x1, ..., x3) ) = max{0, 2x1 - 2} |
POL( U72(x1, x2) ) = max{0, -2} |
POL( U91(x1, ..., x4) ) = x2 + 2x4 |
POL( U92(x1, ..., x4) ) = x2 + 2x4 |
POL( U93(x1, ..., x4) ) = x2 + 2x4 |
POL( cons(x1, x2) ) = 2x1 + x2 |
POL( length(x1) ) = 2x1 + 2 |
POL( s(x1) ) = max{0, -2} |
POL( isNatList(x1) ) = x1 + 2 |
POL( isNatIList(x1) ) = x1 + 2 |
POL( n__take(x1, x2) ) = x2 |
POL( n__length(x1) ) = 2x1 + 2 |
POL( n__cons(x1, x2) ) = 2x1 + x2 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(121) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(122) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATILIST(n__cons(n__take(x0, x1), y1)) → U411(isNat(take(activate(x0), activate(x1))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U411(x1, x2) ) = x1 + 2x2 |
POL( ISNATILIST(x1) ) = 2x1 + 1 |
POL( U61(x1, x2) ) = 2x1 + 2x2 + 2 |
POL( U71(x1, ..., x3) ) = 2x2 + x3 + 2 |
POL( U72(x1, x2) ) = x1 + 2x2 + 1 |
POL( U91(x1, ..., x4) ) = 2x2 + 2x3 + 2x4 + 2 |
POL( U92(x1, ..., x4) ) = 2x2 + 2x3 + x4 + 2 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x3 + x4 + 2 |
POL( cons(x1, x2) ) = x1 + x2 |
POL( length(x1) ) = 2x1 + 2 |
POL( take(x1, x2) ) = 2x1 + 2x2 + 2 |
POL( isNatList(x1) ) = 2x1 |
POL( isNat(x1) ) = x1 + 1 |
POL( isNatIList(x1) ) = 2x1 + 2 |
POL( n__take(x1, x2) ) = 2x1 + 2x2 + 2 |
POL( n__length(x1) ) = 2x1 + 2 |
POL( n__cons(x1, x2) ) = x1 + x2 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(123) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(124) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATILIST(n__cons(n__s(x0), y1)) → U411(isNat(s(activate(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U411(x1, x2) ) = 2x1 + 2x2 + 2 |
POL( ISNATILIST(x1) ) = 2x1 + 2 |
POL( U51(x1, x2) ) = max{0, -2} |
POL( U71(x1, ..., x3) ) = 2x1 + 2x3 + 1 |
POL( U91(x1, ..., x4) ) = x1 + 2x2 + 2x4 |
POL( U92(x1, ..., x4) ) = 2x2 + 2x4 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x4 |
POL( cons(x1, x2) ) = 2x1 + x2 |
POL( length(x1) ) = x1 + 2 |
POL( take(x1, x2) ) = 2x2 |
POL( U21(x1) ) = max{0, 2x1 - 2} |
POL( U31(x1) ) = max{0, -2} |
POL( U42(x1) ) = max{0, -2} |
POL( isNatIList(x1) ) = 0 |
POL( n__take(x1, x2) ) = 2x2 |
POL( n__length(x1) ) = x1 + 2 |
POL( n__cons(x1, x2) ) = 2x1 + x2 |
POL( U81(x1) ) = max{0, -2} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
cons(X1, X2) → n__cons(X1, X2)
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(125) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(126) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U411(tt, n__length(x0)) → ISNATILIST(length(activate(x0)))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U411(x1, x2) ) = 2x2 + 2 |
POL( ISNATILIST(x1) ) = x1 + 2 |
POL( U41(x1, x2) ) = max{0, 2x1 - 1} |
POL( U51(x1, x2) ) = max{0, 2x1 + 2x2 - 1} |
POL( U71(x1, ..., x3) ) = x1 + x2 + 1 |
POL( U91(x1, ..., x4) ) = max{0, x1 - 1} |
POL( U92(x1, ..., x4) ) = max{0, 2x1 - 2} |
POL( U93(x1, ..., x4) ) = max{0, 2x1 - 2} |
POL( cons(x1, x2) ) = 2x2 |
POL( length(x1) ) = x1 + 2 |
POL( take(x1, x2) ) = max{0, -2} |
POL( isNatList(x1) ) = x1 + 1 |
POL( U21(x1) ) = max{0, 2x1 - 1} |
POL( isNatIList(x1) ) = 1 |
POL( U52(x1) ) = max{0, 2x1 - 1} |
POL( U62(x1) ) = max{0, 2x1 - 1} |
POL( n__take(x1, x2) ) = max{0, -2} |
POL( n__length(x1) ) = x1 + 2 |
POL( n__cons(x1, x2) ) = 2x2 |
POL( U81(x1) ) = max{0, -2} |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(127) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(128) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U411(tt, n__s(x0)) → ISNATILIST(s(activate(x0)))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( U411(x1, x2) ) = max{0, 2x1 + 2x2 - 1} |
POL( ISNATILIST(x1) ) = x1 + 1 |
POL( U51(x1, x2) ) = x1 + 2x2 + 1 |
POL( U61(x1, x2) ) = x2 + 2 |
POL( U71(x1, ..., x3) ) = 2 |
POL( U91(x1, ..., x4) ) = max{0, 2x1 + 2x2 + 2x4 - 2} |
POL( U92(x1, ..., x4) ) = 2x2 + 2x4 |
POL( U93(x1, ..., x4) ) = 2x2 + 2x4 |
POL( cons(x1, x2) ) = 2x1 + 2x2 |
POL( length(x1) ) = x1 + 2 |
POL( isNatList(x1) ) = x1 + 2 |
POL( isNat(x1) ) = x1 + 1 |
POL( isNatIList(x1) ) = 1 |
POL( n__take(x1, x2) ) = x2 |
POL( n__length(x1) ) = x1 + 2 |
POL( n__cons(x1, x2) ) = 2x1 + 2x2 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
length(nil) → 0
length(X) → n__length(X)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(129) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(130) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U411(tt, n__take(x0, x1)) → ISNATILIST(take(activate(x0), activate(x1)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]:
POL(U411(x1, x2)) = | 3A | + | -I | · | x1 | + | 1A | · | x2 |
POL(n__take(x1, x2)) = | 3A | + | 1A | · | x1 | + | 1A | · | x2 |
POL(ISNATILIST(x1)) = | 3A | + | 0A | · | x1 |
POL(take(x1, x2)) = | 3A | + | 1A | · | x1 | + | 1A | · | x2 |
POL(activate(x1)) = | 2A | + | 0A | · | x1 |
POL(n__cons(x1, x2)) = | 2A | + | -I | · | x1 | + | 1A | · | x2 |
POL(isNat(x1)) = | 4A | + | -I | · | x1 |
POL(cons(x1, x2)) = | 2A | + | -I | · | x1 | + | 1A | · | x2 |
POL(n__length(x1)) = | 3A | + | 0A | · | x1 |
POL(length(x1)) = | 3A | + | 0A | · | x1 |
POL(n__s(x1)) = | 3A | + | 1A | · | x1 |
POL(U81(x1)) = | 3A | + | -I | · | x1 |
POL(isNatIList(x1)) = | 4A | + | -I | · | x1 |
POL(U91(x1, x2, x3, x4)) = | 3A | + | 0A | · | x1 | + | 2A | · | x2 | + | 2A | · | x3 | + | -I | · | x4 |
POL(U11(x1)) = | 4A | + | -I | · | x1 |
POL(isNatList(x1)) = | 2A | + | 1A | · | x1 |
POL(U21(x1)) = | 4A | + | -I | · | x1 |
POL(U71(x1, x2, x3)) = | 3A | + | 0A | · | x1 | + | 1A | · | x2 | + | -I | · | x3 |
POL(U51(x1, x2)) = | 3A | + | -I | · | x1 | + | 1A | · | x2 |
POL(U61(x1, x2)) = | 4A | + | -I | · | x1 | + | -I | · | x2 |
POL(U62(x1)) = | 4A | + | 0A | · | x1 |
POL(U31(x1)) = | 4A | + | -I | · | x1 |
POL(U41(x1, x2)) = | 4A | + | -I | · | x1 | + | -I | · | x2 |
POL(U42(x1)) = | 4A | + | -I | · | x1 |
POL(U52(x1)) = | 2A | + | 0A | · | x1 |
POL(U72(x1, x2)) = | 4A | + | -I | · | x1 | + | 1A | · | x2 |
POL(U92(x1, x2, x3, x4)) = | 4A | + | 0A | · | x1 | + | 2A | · | x2 | + | 2A | · | x3 | + | -I | · | x4 |
POL(U93(x1, x2, x3, x4)) = | 4A | + | -I | · | x1 | + | 2A | · | x2 | + | 2A | · | x3 | + | -I | · | x4 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
take(X1, X2) → n__take(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(131) Obligation:
Q DP problem:
The TRS P consists of the following rules:
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(132) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
ISNATILIST(n__cons(n__cons(x0, x1), y1)) → U411(isNat(cons(activate(x0), x1)), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] to (N^2, +, *, >=, >) :
POL(ISNATILIST(x1)) = | 1 | + | | · | x1 |
POL(n__cons(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U411(x1, x2)) = | 1 | + | | · | x1 | + | | · | x2 |
POL(cons(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(activate(x1)) = | | + | | · | x1 |
POL(n__take(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(take(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(n__length(x1)) = | | + | | · | x1 |
POL(isNatList(x1)) = | | + | | · | x1 |
POL(U71(x1, x2, x3)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 |
POL(U51(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U61(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(isNatIList(x1)) = | | + | | · | x1 |
POL(U41(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U72(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
POL(U91(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
POL(U92(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
POL(U93(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
cons(X1, X2) → n__cons(X1, X2)
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
0 → n__0
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
U11(tt) → tt
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
isNatIList(n__zeros) → tt
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
nil → n__nil
(133) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U411(tt, n__cons(x0, x1)) → ISNATILIST(cons(activate(x0), x1))
ISNATILIST(n__cons(x0, y1)) → U411(isNat(x0), activate(y1))
U411(tt, x0) → ISNATILIST(x0)
ISNATILIST(n__cons(n__0, y0)) → U411(isNat(n__0), activate(y0))
U411(tt, n__zeros) → ISNATILIST(n__cons(0, n__zeros))
U411(tt, n__zeros) → ISNATILIST(n__cons(n__0, n__zeros))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(134) NonTerminationLoopProof (COMPLETE transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
U411(
isNat(
n__0),
activate(
n__zeros)) evaluates to t =
U411(
isNat(
n__0),
activate(
n__zeros))
Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Matcher: [ ]
- Semiunifier: [ ]
Rewriting sequenceU411(isNat(n__0), activate(n__zeros)) →
U411(
isNat(
n__0),
n__zeros)
with rule
activate(
X) →
X at position [1] and matcher [
X /
n__zeros]
U411(isNat(n__0), n__zeros) →
U411(
tt,
n__zeros)
with rule
isNat(
n__0) →
tt at position [0] and matcher [ ]
U411(tt, n__zeros) →
ISNATILIST(
n__cons(
n__0,
n__zeros))
with rule
U411(
tt,
n__zeros) →
ISNATILIST(
n__cons(
n__0,
n__zeros)) at position [] and matcher [ ]
ISNATILIST(n__cons(n__0, n__zeros)) →
U411(
isNat(
n__0),
activate(
n__zeros))
with rule
ISNATILIST(
n__cons(
x0,
y1)) →
U411(
isNat(
x0),
activate(
y1))
Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(135) NO
(136) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
U721(tt, L) → LENGTH(activate(L))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(137) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
U711(tt, L, N) → U721(isNat(activate(N)), activate(L))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation:
POL( LENGTH(x1) ) = 2x1 + 2 |
POL( U711(x1, ..., x3) ) = x1 + 2x2 + 2 |
POL( U721(x1, x2) ) = 2x2 + 2 |
POL( U71(x1, ..., x3) ) = 2x2 |
POL( U91(x1, ..., x4) ) = 2x3 |
POL( U92(x1, ..., x4) ) = 2x3 |
POL( U93(x1, ..., x4) ) = 2x3 |
POL( cons(x1, x2) ) = 2x2 |
POL( isNatList(x1) ) = x1 |
POL( U21(x1) ) = max{0, 2x1 - 1} |
POL( isNatIList(x1) ) = 2 |
POL( n__take(x1, x2) ) = x1 |
POL( n__length(x1) ) = x1 |
POL( n__cons(x1, x2) ) = 2x2 |
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
take(X1, X2) → n__take(X1, X2)
length(nil) → 0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
U11(tt) → tt
U21(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
isNatIList(V) → U31(isNatList(activate(V)))
U31(tt) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
take(0, IL) → U81(isNatIList(IL))
U81(tt) → nil
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
zeros → cons(0, n__zeros)
zeros → n__zeros
0 → n__0
nil → n__nil
(138) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LENGTH(cons(N, L)) → U711(isNatList(activate(L)), activate(L), N)
U721(tt, L) → LENGTH(activate(L))
The TRS R consists of the following rules:
zeros → cons(0, n__zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(activate(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(activate(V2)))
U52(tt) → tt
U61(tt, V2) → U62(isNatIList(activate(V2)))
U62(tt) → tt
U71(tt, L, N) → U72(isNat(activate(N)), activate(L))
U72(tt, L) → s(length(activate(L)))
U81(tt) → nil
U91(tt, IL, M, N) → U92(isNat(activate(M)), activate(IL), activate(M), activate(N))
U92(tt, IL, M, N) → U93(isNat(activate(N)), activate(IL), activate(M), activate(N))
U93(tt, IL, M, N) → cons(activate(N), n__take(activate(M), activate(IL)))
isNat(n__0) → tt
isNat(n__length(V1)) → U11(isNatList(activate(V1)))
isNat(n__s(V1)) → U21(isNat(activate(V1)))
isNatIList(V) → U31(isNatList(activate(V)))
isNatIList(n__zeros) → tt
isNatIList(n__cons(V1, V2)) → U41(isNat(activate(V1)), activate(V2))
isNatList(n__nil) → tt
isNatList(n__cons(V1, V2)) → U51(isNat(activate(V1)), activate(V2))
isNatList(n__take(V1, V2)) → U61(isNat(activate(V1)), activate(V2))
length(nil) → 0
length(cons(N, L)) → U71(isNatList(activate(L)), activate(L), N)
take(0, IL) → U81(isNatIList(IL))
take(s(M), cons(N, IL)) → U91(isNatIList(activate(IL)), activate(IL), M, N)
zeros → n__zeros
take(X1, X2) → n__take(X1, X2)
0 → n__0
length(X) → n__length(X)
s(X) → n__s(X)
cons(X1, X2) → n__cons(X1, X2)
nil → n__nil
activate(n__zeros) → zeros
activate(n__take(X1, X2)) → take(activate(X1), activate(X2))
activate(n__0) → 0
activate(n__length(X)) → length(activate(X))
activate(n__s(X)) → s(activate(X))
activate(n__cons(X1, X2)) → cons(activate(X1), X2)
activate(n__nil) → nil
activate(X) → X
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(139) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.
(140) TRUE