/export/starexec/sandbox/solver/bin/starexec_run_standard /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


NO
proof of /export/starexec/sandbox/benchmark/theBenchmark.xml
# AProVE Commit ID: c69e44bd14796315568835c1ffa2502984884775 mhark 20210624 unpublished


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

(0) QTRS
(1) DependencyPairsProof [EQUIVALENT, 0 ms]
(2) QDP
(3) DependencyGraphProof [EQUIVALENT, 0 ms]
(4) QDP
(5) QDPOrderProof [EQUIVALENT, 1066 ms]
(6) QDP
(7) DependencyGraphProof [EQUIVALENT, 0 ms]
(8) AND
    (9) QDP
        (10) QDPOrderProof [EQUIVALENT, 162 ms]
        (11) QDP
        (12) DependencyGraphProof [EQUIVALENT, 0 ms]
        (13) TRUE
    (14) QDP
        (15) UsableRulesProof [EQUIVALENT, 0 ms]
        (16) QDP
        (17) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (18) YES
    (19) QDP
        (20) QDPOrderProof [EQUIVALENT, 170 ms]
        (21) QDP
        (22) PisEmptyProof [EQUIVALENT, 0 ms]
        (23) YES
    (24) QDP
        (25) TransformationProof [EQUIVALENT, 0 ms]
        (26) QDP
        (27) TransformationProof [EQUIVALENT, 0 ms]
        (28) QDP
        (29) TransformationProof [EQUIVALENT, 0 ms]
        (30) QDP
        (31) DependencyGraphProof [EQUIVALENT, 0 ms]
        (32) QDP
        (33) TransformationProof [EQUIVALENT, 0 ms]
        (34) QDP
        (35) DependencyGraphProof [EQUIVALENT, 0 ms]
        (36) QDP
        (37) TransformationProof [EQUIVALENT, 0 ms]
        (38) QDP
        (39) TransformationProof [EQUIVALENT, 8 ms]
        (40) QDP
        (41) DependencyGraphProof [EQUIVALENT, 0 ms]
        (42) QDP
        (43) TransformationProof [EQUIVALENT, 0 ms]
        (44) QDP
        (45) DependencyGraphProof [EQUIVALENT, 0 ms]
        (46) QDP
        (47) TransformationProof [EQUIVALENT, 6 ms]
        (48) QDP
        (49) DependencyGraphProof [EQUIVALENT, 0 ms]
        (50) QDP
        (51) TransformationProof [EQUIVALENT, 0 ms]
        (52) QDP
        (53) TransformationProof [EQUIVALENT, 0 ms]
        (54) QDP
        (55) DependencyGraphProof [EQUIVALENT, 0 ms]
        (56) QDP
        (57) TransformationProof [EQUIVALENT, 15 ms]
        (58) QDP
        (59) DependencyGraphProof [EQUIVALENT, 0 ms]
        (60) QDP
        (61) TransformationProof [EQUIVALENT, 0 ms]
        (62) QDP
        (63) QDPOrderProof [EQUIVALENT, 256 ms]
        (64) QDP
        (65) QDPOrderProof [EQUIVALENT, 265 ms]
        (66) QDP
        (67) QDPOrderProof [EQUIVALENT, 668 ms]
        (68) QDP
        (69) QDPOrderProof [EQUIVALENT, 92 ms]
        (70) QDP
    (71) QDP
        (72) TransformationProof [EQUIVALENT, 0 ms]
        (73) QDP
        (74) TransformationProof [EQUIVALENT, 0 ms]
        (75) QDP
        (76) TransformationProof [EQUIVALENT, 0 ms]
        (77) QDP
        (78) DependencyGraphProof [EQUIVALENT, 0 ms]
        (79) QDP
        (80) TransformationProof [EQUIVALENT, 0 ms]
        (81) QDP
        (82) DependencyGraphProof [EQUIVALENT, 0 ms]
        (83) QDP
        (84) TransformationProof [EQUIVALENT, 0 ms]
        (85) QDP
        (86) DependencyGraphProof [EQUIVALENT, 0 ms]
        (87) QDP
        (88) TransformationProof [EQUIVALENT, 0 ms]
        (89) QDP
        (90) TransformationProof [EQUIVALENT, 8 ms]
        (91) QDP
        (92) DependencyGraphProof [EQUIVALENT, 0 ms]
        (93) QDP
        (94) TransformationProof [EQUIVALENT, 0 ms]
        (95) QDP
        (96) DependencyGraphProof [EQUIVALENT, 0 ms]
        (97) QDP
        (98) TransformationProof [EQUIVALENT, 19 ms]
        (99) QDP
        (100) DependencyGraphProof [EQUIVALENT, 0 ms]
        (101) QDP
        (102) TransformationProof [EQUIVALENT, 23 ms]
        (103) QDP
        (104) TransformationProof [EQUIVALENT, 0 ms]
        (105) QDP
        (106) DependencyGraphProof [EQUIVALENT, 0 ms]
        (107) QDP
        (108) TransformationProof [EQUIVALENT, 0 ms]
        (109) QDP
        (110) QDPOrderProof [EQUIVALENT, 70 ms]
        (111) QDP
        (112) QDPOrderProof [EQUIVALENT, 258 ms]
        (113) QDP
        (114) QDPOrderProof [EQUIVALENT, 257 ms]
        (115) QDP
        (116) QDPOrderProof [EQUIVALENT, 986 ms]
        (117) QDP
        (118) QDPOrderProof [EQUIVALENT, 60 ms]
        (119) QDP
        (120) NonTerminationLoopProof [COMPLETE, 88 ms]
        (121) NO


----------------------------------------

(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)
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 -> 0^1
   U41^1(tt, V2) -> U42^1(isNatIList(activate(V2)))
   U41^1(tt, V2) -> ISNATILIST(activate(V2))
   U41^1(tt, V2) -> ACTIVATE(V2)
   U51^1(tt, V2) -> U52^1(isNatList(activate(V2)))
   U51^1(tt, V2) -> ISNATLIST(activate(V2))
   U51^1(tt, V2) -> ACTIVATE(V2)
   U61^1(tt, V2) -> U62^1(isNatIList(activate(V2)))
   U61^1(tt, V2) -> ISNATILIST(activate(V2))
   U61^1(tt, V2) -> ACTIVATE(V2)
   U71^1(tt, L, N) -> U72^1(isNat(activate(N)), activate(L))
   U71^1(tt, L, N) -> ISNAT(activate(N))
   U71^1(tt, L, N) -> ACTIVATE(N)
   U71^1(tt, L, N) -> ACTIVATE(L)
   U72^1(tt, L) -> S(length(activate(L)))
   U72^1(tt, L) -> LENGTH(activate(L))
   U72^1(tt, L) -> ACTIVATE(L)
   U81^1(tt) -> NIL
   U91^1(tt, IL, M, N) -> U92^1(isNat(activate(M)), activate(IL), activate(M), activate(N))
   U91^1(tt, IL, M, N) -> ISNAT(activate(M))
   U91^1(tt, IL, M, N) -> ACTIVATE(M)
   U91^1(tt, IL, M, N) -> ACTIVATE(IL)
   U91^1(tt, IL, M, N) -> ACTIVATE(N)
   U92^1(tt, IL, M, N) -> U93^1(isNat(activate(N)), activate(IL), activate(M), activate(N))
   U92^1(tt, IL, M, N) -> ISNAT(activate(N))
   U92^1(tt, IL, M, N) -> ACTIVATE(N)
   U92^1(tt, IL, M, N) -> ACTIVATE(IL)
   U92^1(tt, IL, M, N) -> ACTIVATE(M)
   U93^1(tt, IL, M, N) -> CONS(activate(N), n__take(activate(M), activate(IL)))
   U93^1(tt, IL, M, N) -> ACTIVATE(N)
   U93^1(tt, IL, M, N) -> ACTIVATE(M)
   U93^1(tt, IL, M, N) -> ACTIVATE(IL)
   ISNAT(n__length(V1)) -> U11^1(isNatList(activate(V1)))
   ISNAT(n__length(V1)) -> ISNATLIST(activate(V1))
   ISNAT(n__length(V1)) -> ACTIVATE(V1)
   ISNAT(n__s(V1)) -> U21^1(isNat(activate(V1)))
   ISNAT(n__s(V1)) -> ISNAT(activate(V1))
   ISNAT(n__s(V1)) -> ACTIVATE(V1)
   ISNATILIST(V) -> U31^1(isNatList(activate(V)))
   ISNATILIST(V) -> ISNATLIST(activate(V))
   ISNATILIST(V) -> ACTIVATE(V)
   ISNATILIST(n__cons(V1, V2)) -> U41^1(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)) -> U51^1(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)) -> U61^1(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) -> 0^1
   LENGTH(cons(N, L)) -> U71^1(isNatList(activate(L)), activate(L), N)
   LENGTH(cons(N, L)) -> ISNATLIST(activate(L))
   LENGTH(cons(N, L)) -> ACTIVATE(L)
   TAKE(0, IL) -> U81^1(isNatIList(IL))
   TAKE(0, IL) -> ISNATILIST(IL)
   TAKE(s(M), cons(N, IL)) -> U91^1(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) -> 0^1
   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)
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)) -> U51^1(isNat(activate(V1)), activate(V2))
   U51^1(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)) -> U71^1(isNatList(activate(L)), activate(L), N)
   U71^1(tt, L, N) -> U72^1(isNat(activate(N)), activate(L))
   U72^1(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)) -> U61^1(isNat(activate(V1)), activate(V2))
   U61^1(tt, V2) -> ISNATILIST(activate(V2))
   ISNATILIST(V) -> ACTIVATE(V)
   ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2))
   U41^1(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)
   U41^1(tt, V2) -> ACTIVATE(V2)
   U61^1(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)
   U72^1(tt, L) -> ACTIVATE(L)
   U71^1(tt, L, N) -> ISNAT(activate(N))
   U71^1(tt, L, N) -> ACTIVATE(N)
   U71^1(tt, L, N) -> ACTIVATE(L)
   U51^1(tt, V2) -> ACTIVATE(V2)
   TAKE(s(M), cons(N, IL)) -> U91^1(isNatIList(activate(IL)), activate(IL), M, N)
   U91^1(tt, IL, M, N) -> U92^1(isNat(activate(M)), activate(IL), activate(M), activate(N))
   U92^1(tt, IL, M, N) -> U93^1(isNat(activate(N)), activate(IL), activate(M), activate(N))
   U93^1(tt, IL, M, N) -> ACTIVATE(N)
   U93^1(tt, IL, M, N) -> ACTIVATE(M)
   U93^1(tt, IL, M, N) -> ACTIVATE(IL)
   U92^1(tt, IL, M, N) -> ISNAT(activate(N))
   U92^1(tt, IL, M, N) -> ACTIVATE(N)
   U92^1(tt, IL, M, N) -> ACTIVATE(IL)
   U92^1(tt, IL, M, N) -> ACTIVATE(M)
   U91^1(tt, IL, M, N) -> ISNAT(activate(M))
   U91^1(tt, IL, M, N) -> ACTIVATE(M)
   U91^1(tt, IL, M, N) -> ACTIVATE(IL)
   U91^1(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)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   ACTIVATE(n__take(X1, X2)) -> TAKE(activate(X1), activate(X2))
   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)
   LENGTH(cons(N, L)) -> ISNATLIST(activate(L))
   ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V2)
   ACTIVATE(n__length(X)) -> ACTIVATE(X)
   ISNATLIST(n__take(V1, V2)) -> U61^1(isNat(activate(V1)), activate(V2))
   ISNATILIST(V) -> ACTIVATE(V)
   ISNATILIST(n__cons(V1, V2)) -> ISNAT(activate(V1))
   ISNAT(n__length(V1)) -> ACTIVATE(V1)
   ISNATILIST(n__cons(V1, V2)) -> ACTIVATE(V1)
   ISNATILIST(n__cons(V1, V2)) -> ACTIVATE(V2)
   U41^1(tt, V2) -> ACTIVATE(V2)
   U61^1(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)
   U72^1(tt, L) -> ACTIVATE(L)
   U71^1(tt, L, N) -> ISNAT(activate(N))
   U71^1(tt, L, N) -> ACTIVATE(N)
   U71^1(tt, L, N) -> ACTIVATE(L)
   U51^1(tt, V2) -> ACTIVATE(V2)
   U93^1(tt, IL, M, N) -> ACTIVATE(N)
   U93^1(tt, IL, M, N) -> ACTIVATE(M)
   U93^1(tt, IL, M, N) -> ACTIVATE(IL)
   U92^1(tt, IL, M, N) -> ISNAT(activate(N))
   U92^1(tt, IL, M, N) -> ACTIVATE(N)
   U92^1(tt, IL, M, N) -> ACTIVATE(IL)
   U92^1(tt, IL, M, N) -> ACTIVATE(M)
   U91^1(tt, IL, M, N) -> ISNAT(activate(M))
   U91^1(tt, IL, M, N) -> ACTIVATE(M)
   U91^1(tt, IL, M, N) -> ACTIVATE(IL)
   U91^1(tt, IL, M, N) -> ACTIVATE(N)
   TAKE(s(M), cons(N, IL)) -> ACTIVATE(IL)
The remaining pairs can at least be oriented weakly.
Used ordering:  Polynomial Order [NEGPOLO,POLO] with Interpretation:

POL( ISNAT_1(x_1) ) = 2x_1
POL( ISNATILIST_1(x_1) ) = 2x_1 + 1
POL( ISNATLIST_1(x_1) ) = x_1 + 1
POL( LENGTH_1(x_1) ) = 2x_1 + 2
POL( TAKE_2(x_1, x_2) ) = 2x_1 + 2x_2 + 1
POL( U41^1_2(x_1, x_2) ) = 2x_2 + 1
POL( U51^1_2(x_1, x_2) ) = x_2 + 1
POL( U61^1_2(x_1, x_2) ) = 2x_2 + 1
POL( U71^1_3(x_1, ..., x_3) ) = 2x_2 + 2x_3 + 2
POL( U72^1_2(x_1, x_2) ) = 2x_2 + 2
POL( U91^1_4(x_1, ..., x_4) ) = 2x_2 + 2x_3 + 2x_4 + 1
POL( U92^1_4(x_1, ..., x_4) ) = 2x_2 + 2x_3 + 2x_4 + 1
POL( U93^1_4(x_1, ..., x_4) ) = 2x_2 + x_3 + 2x_4 + 1
POL( U41_2(x_1, x_2) ) = max{0, -2}
POL( U51_2(x_1, x_2) ) = max{0, -2}
POL( U61_2(x_1, x_2) ) = max{0, -2}
POL( U71_3(x_1, ..., x_3) ) = 2x_2 + 2x_3 + 2
POL( U72_2(x_1, x_2) ) = 2x_2 + 2
POL( U91_4(x_1, ..., x_4) ) = 2x_2 + 2x_3 + 2x_4 + 2
POL( U92_4(x_1, ..., x_4) ) = 2x_2 + 2x_3 + 2x_4 + 2
POL( U93_4(x_1, ..., x_4) ) = 2x_2 + 2x_3 + 2x_4 + 2
POL( cons_2(x_1, x_2) ) = 2x_1 + x_2
POL( isNat_1(x_1) ) = max{0, -2}
POL( length_1(x_1) ) = 2x_1 + 2
POL( s_1(x_1) ) = x_1
POL( take_2(x_1, x_2) ) = 2x_1 + 2x_2 + 2
POL( isNatList_1(x_1) ) = max{0, -2}
POL( isNatIList_1(x_1) ) = max{0, -2}
POL( U11_1(x_1) ) = max{0, -2}
POL( U21_1(x_1) ) = max{0, -2}
POL( U31_1(x_1) ) = max{0, -2}
POL( U42_1(x_1) ) = max{0, -2}
POL( U52_1(x_1) ) = max{0, -2}
POL( U62_1(x_1) ) = max{0, -2}
POL( n__take_2(x_1, x_2) ) = 2x_1 + 2x_2 + 2
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 0
POL( 0 ) = 0
POL( n__length_1(x_1) ) = 2x_1 + 2
POL( n__s_1(x_1) ) = x_1
POL( n__cons_2(x_1, x_2) ) = 2x_1 + x_2
POL( n__nil ) = 0
POL( nil ) = 0
POL( tt ) = 0
POL( U81_1(x_1) ) = max{0, -2}
POL( ACTIVATE_1(x_1) ) = x_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
   isNat(n__length(V1)) -> U11(isNatList(activate(V1)))
   isNat(n__s(V1)) -> U21(isNat(activate(V1)))
   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__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:

   TAKE(0, IL) -> ISNATILIST(IL)
   ISNATILIST(V) -> ISNATLIST(activate(V))
   ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2))
   U51^1(tt, V2) -> ISNATLIST(activate(V2))
   ACTIVATE(n__length(X)) -> LENGTH(activate(X))
   LENGTH(cons(N, L)) -> U71^1(isNatList(activate(L)), activate(L), N)
   U71^1(tt, L, N) -> U72^1(isNat(activate(N)), activate(L))
   U72^1(tt, L) -> LENGTH(activate(L))
   ACTIVATE(n__s(X)) -> ACTIVATE(X)
   ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1)
   U61^1(tt, V2) -> ISNATILIST(activate(V2))
   ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2))
   U41^1(tt, V2) -> ISNATILIST(activate(V2))
   ISNAT(n__s(V1)) -> ISNAT(activate(V1))
   ISNAT(n__s(V1)) -> ACTIVATE(V1)
   TAKE(s(M), cons(N, IL)) -> U91^1(isNatIList(activate(IL)), activate(IL), M, N)
   U91^1(tt, IL, M, N) -> U92^1(isNat(activate(M)), activate(IL), activate(M), activate(N))
   U92^1(tt, IL, M, N) -> U93^1(isNat(activate(N)), activate(IL), activate(M), activate(N))
   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.
----------------------------------------

(7) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 5 SCCs with 9 less nodes.
----------------------------------------

(8)
Complex Obligation (AND)

----------------------------------------

(9)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U71^1(tt, L, N) -> U72^1(isNat(activate(N)), activate(L))
   U72^1(tt, L) -> LENGTH(activate(L))
   LENGTH(cons(N, L)) -> U71^1(isNatList(activate(L)), activate(L), N)

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.
----------------------------------------

(10) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   U71^1(tt, L, N) -> U72^1(isNat(activate(N)), activate(L))
The remaining pairs can at least be oriented weakly.
Used ordering:  Polynomial Order [NEGPOLO,POLO] with Interpretation:

POL( LENGTH_1(x_1) ) = 2x_1 + 2
POL( U71^1_3(x_1, ..., x_3) ) = 2x_1 + 2x_2 + 2
POL( U72^1_2(x_1, x_2) ) = 2x_2 + 2
POL( U41_2(x_1, x_2) ) = 2
POL( U51_2(x_1, x_2) ) = 2x_2
POL( U61_2(x_1, x_2) ) = x_1
POL( U71_3(x_1, ..., x_3) ) = 2x_2
POL( U72_2(x_1, x_2) ) = 2x_2
POL( U91_4(x_1, ..., x_4) ) = 2x_3
POL( U92_4(x_1, ..., x_4) ) = 2x_3
POL( U93_4(x_1, ..., x_4) ) = 2x_3
POL( cons_2(x_1, x_2) ) = 2x_2
POL( isNatList_1(x_1) ) = x_1
POL( length_1(x_1) ) = x_1
POL( s_1(x_1) ) = 2x_1
POL( take_2(x_1, x_2) ) = x_1
POL( isNat_1(x_1) ) = x_1
POL( U11_1(x_1) ) = x_1
POL( U21_1(x_1) ) = max{0, 2x_1 - 2}
POL( U31_1(x_1) ) = 2
POL( U42_1(x_1) ) = x_1
POL( isNatIList_1(x_1) ) = 2
POL( U52_1(x_1) ) = max{0, 2x_1 - 2}
POL( U62_1(x_1) ) = x_1
POL( n__take_2(x_1, x_2) ) = x_1
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 2
POL( 0 ) = 2
POL( n__length_1(x_1) ) = x_1
POL( n__s_1(x_1) ) = 2x_1
POL( n__cons_2(x_1, x_2) ) = 2x_2
POL( n__nil ) = 2
POL( nil ) = 2
POL( tt ) = 2
POL( U81_1(x_1) ) = 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__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


----------------------------------------

(11)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U72^1(tt, L) -> LENGTH(activate(L))
   LENGTH(cons(N, L)) -> U71^1(isNatList(activate(L)), activate(L), N)

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.
----------------------------------------

(12) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.
----------------------------------------

(13)
TRUE

----------------------------------------

(14)
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.
----------------------------------------

(15) UsableRulesProof (EQUIVALENT)
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.
----------------------------------------

(16)
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.
----------------------------------------

(17) QDPSizeChangeProof (EQUIVALENT)
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


----------------------------------------

(18)
YES

----------------------------------------

(19)
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.
----------------------------------------

(20) QDPOrderProof (EQUIVALENT)
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(x_1)) =  	[[5A]] 	 +  	[[3A]] 	* 	x_1
>>>

   <<<
 POL(n__s(x_1)) =  	[[3A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(activate(x_1)) =  	[[1A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__zeros) =  	[[0A]]
>>>

   <<<
 POL(zeros) =  	[[1A]]
>>>

   <<<
 POL(n__take(x_1, x_2)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(take(x_1, x_2)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(n__0) =  	[[0A]]
>>>

   <<<
 POL(0) =  	[[1A]]
>>>

   <<<
 POL(n__length(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(length(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(s(x_1)) =  	[[3A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(n__cons(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(cons(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(n__nil) =  	[[2A]]
>>>

   <<<
 POL(nil) =  	[[2A]]
>>>

   <<<
 POL(U71(x_1, x_2, x_3)) =  	[[-I]] 	 +  	[[1A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[0A]] 	* 	x_3
>>>

   <<<
 POL(isNatList(x_1)) =  	[[1A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(tt) =  	[[2A]]
>>>

   <<<
 POL(U51(x_1, x_2)) =  	[[1A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(isNat(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U11(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U61(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2
>>>

   <<<
 POL(U21(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U62(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(isNatIList(x_1)) =  	[[2A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(U31(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U41(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(U42(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U52(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U72(x_1, x_2)) =  	[[3A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(U81(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U91(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3 	 +  	[[0A]] 	* 	x_4
>>>

   <<<
 POL(U92(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3 	 +  	[[0A]] 	* 	x_4
>>>

   <<<
 POL(U93(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3 	 +  	[[0A]] 	* 	x_4
>>>


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)))
   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


----------------------------------------

(21)
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.
----------------------------------------

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

(23)
YES

----------------------------------------

(24)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, V2) -> ISNATLIST(activate(V2))
   ISNATLIST(n__cons(V1, V2)) -> U51^1(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.
----------------------------------------

(25) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U51^1(tt, V2) -> ISNATLIST(activate(V2)) at position [0] we obtained the following new rules [LPAR04]:

   (U51^1(tt, n__zeros) -> ISNATLIST(zeros),U51^1(tt, n__zeros) -> ISNATLIST(zeros))
   (U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1))),U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1))))
   (U51^1(tt, n__0) -> ISNATLIST(0),U51^1(tt, n__0) -> ISNATLIST(0))
   (U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))),U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))))
   (U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))),U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))))
   (U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)),U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)))
   (U51^1(tt, n__nil) -> ISNATLIST(nil),U51^1(tt, n__nil) -> ISNATLIST(nil))
   (U51^1(tt, x0) -> ISNATLIST(x0),U51^1(tt, x0) -> ISNATLIST(x0))


----------------------------------------

(26)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2))
   U51^1(tt, n__zeros) -> ISNATLIST(zeros)
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   U51^1(tt, n__0) -> ISNATLIST(0)
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   U51^1(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.
----------------------------------------

(27) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)),ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)))
   (ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1)),ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1)))
   (ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)),ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)))
   (ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)),ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)))
   (ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)),ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)))
   (ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)),ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)))
   (ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)),ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)))
   (ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)),ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)))


----------------------------------------

(28)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__zeros) -> ISNATLIST(zeros)
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   U51^1(tt, n__0) -> ISNATLIST(0)
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   ISNATLIST(n__cons(x0, y1)) -> U51^1(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.
----------------------------------------

(29) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U51^1(tt, n__zeros) -> ISNATLIST(zeros) at position [0] we obtained the following new rules [LPAR04]:

   (U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)))
   (U51^1(tt, n__zeros) -> ISNATLIST(n__zeros),U51^1(tt, n__zeros) -> ISNATLIST(n__zeros))


----------------------------------------

(30)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   U51^1(tt, n__0) -> ISNATLIST(0)
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   U51^1(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.
----------------------------------------

(31) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(32)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__0) -> ISNATLIST(0)
   ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(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.
----------------------------------------

(33) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)))
   (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__zeros), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__zeros), activate(y0)))


----------------------------------------

(34)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__0) -> ISNATLIST(0)
   ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(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.
----------------------------------------

(35) DependencyGraphProof (EQUIVALENT)
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__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1))
   U51^1(tt, n__0) -> ISNATLIST(0)
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   U51^1(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)
By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)),ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)))


----------------------------------------

(38)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   U51^1(tt, n__0) -> ISNATLIST(0)
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(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.
----------------------------------------

(39) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U51^1(tt, n__0) -> ISNATLIST(0) at position [0] we obtained the following new rules [LPAR04]:

   (U51^1(tt, n__0) -> ISNATLIST(n__0),U51^1(tt, n__0) -> ISNATLIST(n__0))


----------------------------------------

(40)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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.
----------------------------------------

(41) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(42)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__nil) -> ISNATLIST(nil)
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(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)
By narrowing [LPAR04] the rule U51^1(tt, n__nil) -> ISNATLIST(nil) at position [0] we obtained the following new rules [LPAR04]:

   (U51^1(tt, n__nil) -> ISNATLIST(n__nil),U51^1(tt, n__nil) -> ISNATLIST(n__nil))


----------------------------------------

(44)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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.
----------------------------------------

(45) DependencyGraphProof (EQUIVALENT)
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:

   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(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)
By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATLIST(n__cons(n__nil, y0)) -> U51^1(isNat(n__nil), activate(y0)),ISNATLIST(n__cons(n__nil, y0)) -> U51^1(isNat(n__nil), activate(y0)))


----------------------------------------

(48)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   ISNATLIST(n__cons(n__nil, y0)) -> U51^1(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.
----------------------------------------

(49) DependencyGraphProof (EQUIVALENT)
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:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(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)
By narrowing [LPAR04] the rule U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]:

   (U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)))
   (U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)))


----------------------------------------

(52)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   U51^1(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.
----------------------------------------

(53) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(0, n__zeros)), activate(y0)))
   (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)))


----------------------------------------

(54)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(0, n__zeros)), activate(y0))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(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.
----------------------------------------

(55) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(56)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0))
   U51^1(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)
By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(n__0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(n__0, n__zeros)), activate(y0)))


----------------------------------------

(58)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros))
   ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(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.
----------------------------------------

(59) DependencyGraphProof (EQUIVALENT)
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:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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)
By narrowing [LPAR04] the rule U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]:

   (U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)))


----------------------------------------

(62)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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.
----------------------------------------

(63) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))
   U51^1(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( U51^1_2(x_1, x_2) ) = 2x_2
POL( ISNATLIST_1(x_1) ) = x_1
POL( U41_2(x_1, x_2) ) = max{0, -2}
POL( U51_2(x_1, x_2) ) = max{0, -2}
POL( U61_2(x_1, x_2) ) = max{0, -2}
POL( U71_3(x_1, ..., x_3) ) = 1
POL( U72_2(x_1, x_2) ) = 1
POL( U91_4(x_1, ..., x_4) ) = max{0, -2}
POL( U92_4(x_1, ..., x_4) ) = max{0, -2}
POL( U93_4(x_1, ..., x_4) ) = max{0, -2}
POL( cons_2(x_1, x_2) ) = 2x_2
POL( length_1(x_1) ) = 1
POL( s_1(x_1) ) = 1
POL( take_2(x_1, x_2) ) = 0
POL( U11_1(x_1) ) = max{0, -2}
POL( isNatList_1(x_1) ) = max{0, -2}
POL( U21_1(x_1) ) = 1
POL( isNat_1(x_1) ) = 1
POL( U31_1(x_1) ) = max{0, -2}
POL( U42_1(x_1) ) = max{0, -2}
POL( isNatIList_1(x_1) ) = max{0, -2}
POL( U52_1(x_1) ) = max{0, -2}
POL( U62_1(x_1) ) = max{0, -2}
POL( n__take_2(x_1, x_2) ) = max{0, -2}
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 0
POL( 0 ) = 0
POL( n__length_1(x_1) ) = 1
POL( n__s_1(x_1) ) = 1
POL( n__cons_2(x_1, x_2) ) = 2x_2
POL( n__nil ) = 0
POL( nil ) = 0
POL( U81_1(x_1) ) = max{0, -2}
POL( tt ) = 0

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__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__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)))
   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


----------------------------------------

(64)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   ISNATLIST(n__cons(n__take(x0, x1), y1)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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.
----------------------------------------

(65) QDPOrderProof (EQUIVALENT)
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)) -> U51^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))
   ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering:  Polynomial Order [NEGPOLO,POLO] with Interpretation:

POL( U51^1_2(x_1, x_2) ) = x_1 + 2x_2
POL( ISNATLIST_1(x_1) ) = 2x_1
POL( U41_2(x_1, x_2) ) = max{0, -2}
POL( U51_2(x_1, x_2) ) = max{0, -2}
POL( U61_2(x_1, x_2) ) = max{0, -2}
POL( U71_3(x_1, ..., x_3) ) = 2
POL( U72_2(x_1, x_2) ) = 2
POL( U91_4(x_1, ..., x_4) ) = 2x_2 + 2x_4 + 2
POL( U92_4(x_1, ..., x_4) ) = 2x_2 + 2x_4 + 2
POL( U93_4(x_1, ..., x_4) ) = 2x_2 + 2x_4 + 2
POL( cons_2(x_1, x_2) ) = 2x_1 + x_2
POL( length_1(x_1) ) = 2
POL( s_1(x_1) ) = 2
POL( take_2(x_1, x_2) ) = 2x_2 + 2
POL( U11_1(x_1) ) = max{0, -2}
POL( isNatList_1(x_1) ) = max{0, -2}
POL( U21_1(x_1) ) = max{0, -2}
POL( isNat_1(x_1) ) = max{0, x_1 - 1}
POL( U31_1(x_1) ) = max{0, -2}
POL( U42_1(x_1) ) = max{0, -2}
POL( isNatIList_1(x_1) ) = max{0, -2}
POL( U52_1(x_1) ) = max{0, -2}
POL( U62_1(x_1) ) = max{0, -2}
POL( n__take_2(x_1, x_2) ) = 2x_2 + 2
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 0
POL( 0 ) = 0
POL( n__length_1(x_1) ) = 2
POL( n__s_1(x_1) ) = 2
POL( n__cons_2(x_1, x_2) ) = 2x_1 + x_2
POL( n__nil ) = 0
POL( nil ) = 0
POL( U81_1(x_1) ) = 2
POL( tt ) = 0

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__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)))
   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


----------------------------------------

(66)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__take(x0, x1)) -> ISNATLIST(take(activate(x0), activate(x1)))
   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   U51^1(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(U51^1(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(tt) =  	[[2A]]
>>>

   <<<
 POL(n__take(x_1, x_2)) =  	[[2A]] 	 +  	[[1A]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2
>>>

   <<<
 POL(ISNATLIST(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(take(x_1, x_2)) =  	[[2A]] 	 +  	[[1A]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2
>>>

   <<<
 POL(activate(x_1)) =  	[[1A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__cons(x_1, x_2)) =  	[[1A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(cons(x_1, x_2)) =  	[[1A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(isNat(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__zeros) =  	[[0A]]
>>>

   <<<
 POL(0) =  	[[1A]]
>>>

   <<<
 POL(n__0) =  	[[0A]]
>>>

   <<<
 POL(zeros) =  	[[1A]]
>>>

   <<<
 POL(n__length(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(length(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__s(x_1)) =  	[[2A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(s(x_1)) =  	[[2A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(n__nil) =  	[[2A]]
>>>

   <<<
 POL(nil) =  	[[2A]]
>>>

   <<<
 POL(U81(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(isNatIList(x_1)) =  	[[1A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(U91(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2 	 +  	[[2A]] 	* 	x_3 	 +  	[[-I]] 	* 	x_4
>>>

   <<<
 POL(U11(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(isNatList(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U21(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U71(x_1, x_2, x_3)) =  	[[-I]] 	 +  	[[1A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[-I]] 	* 	x_3
>>>

   <<<
 POL(U51(x_1, x_2)) =  	[[1A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(U61(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2
>>>

   <<<
 POL(U62(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U31(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U41(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2
>>>

   <<<
 POL(U42(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U52(x_1)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U72(x_1, x_2)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(U92(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2 	 +  	[[2A]] 	* 	x_3 	 +  	[[-I]] 	* 	x_4
>>>

   <<<
 POL(U93(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[-I]] 	* 	x_2 	 +  	[[2A]] 	* 	x_3 	 +  	[[-I]] 	* 	x_4
>>>


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__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)))
   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:

   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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)
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)) -> U51^1(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(U51^1(x_1, x_2)) =  	[[0]] 	 +  	[[0, 0]] 	* 	x_1 	 +  	[[1, 0]] 	* 	x_2
>>>

   <<<
 POL(tt) =  	[[0], [0]]
>>>

   <<<
 POL(n__cons(x_1, x_2)) =  	[[0], [1]] 	 +  	[[0, 1], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(ISNATLIST(x_1)) =  	[[0]] 	 +  	[[1, 0]] 	* 	x_1
>>>

   <<<
 POL(cons(x_1, x_2)) =  	[[0], [1]] 	 +  	[[0, 1], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(activate(x_1)) =  	[[0], [0]] 	 +  	[[1, 0], [0, 1]] 	* 	x_1
>>>

   <<<
 POL(isNat(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(n__zeros) =  	[[0], [1]]
>>>

   <<<
 POL(0) =  	[[0], [0]]
>>>

   <<<
 POL(n__0) =  	[[0], [0]]
>>>

   <<<
 POL(zeros) =  	[[0], [1]]
>>>

   <<<
 POL(n__take(x_1, x_2)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [1, 1]] 	* 	x_2
>>>

   <<<
 POL(take(x_1, x_2)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [1, 1]] 	* 	x_2
>>>

   <<<
 POL(n__length(x_1)) =  	[[1], [1]] 	 +  	[[0, 1], [0, 1]] 	* 	x_1
>>>

   <<<
 POL(length(x_1)) =  	[[1], [1]] 	 +  	[[0, 1], [0, 1]] 	* 	x_1
>>>

   <<<
 POL(n__s(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(s(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(n__nil) =  	[[0], [0]]
>>>

   <<<
 POL(nil) =  	[[0], [0]]
>>>

   <<<
 POL(U11(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(isNatList(x_1)) =  	[[1], [1]] 	 +  	[[0, 0], [1, 0]] 	* 	x_1
>>>

   <<<
 POL(U21(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U71(x_1, x_2, x_3)) =  	[[1], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3
>>>

   <<<
 POL(U51(x_1, x_2)) =  	[[1], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U61(x_1, x_2)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U62(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(isNatIList(x_1)) =  	[[1], [1]] 	 +  	[[0, 0], [1, 1]] 	* 	x_1
>>>

   <<<
 POL(U31(x_1)) =  	[[1], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U41(x_1, x_2)) =  	[[1], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U42(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U52(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U72(x_1, x_2)) =  	[[1], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U81(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U91(x_1, x_2, x_3, x_4)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3 	 +  	[[0, 1], [0, 1]] 	* 	x_4
>>>

   <<<
 POL(U92(x_1, x_2, x_3, x_4)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3 	 +  	[[0, 1], [0, 0]] 	* 	x_4
>>>

   <<<
 POL(U93(x_1, x_2, x_3, x_4)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3 	 +  	[[0, 1], [0, 0]] 	* 	x_4
>>>


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__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)))
   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


----------------------------------------

(70)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))
   U51^1(tt, x0) -> ISNATLIST(x0)
   ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))
   U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))
   ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))
   U51^1(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)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2))
   U41^1(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.
----------------------------------------

(72) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)),ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)))
   (ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1)),ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1)))
   (ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)),ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)))
   (ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)),ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)))
   (ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)),ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)))
   (ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)),ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)))
   (ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)),ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)))
   (ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)),ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)))


----------------------------------------

(73)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, V2) -> ISNATILIST(activate(V2))
   ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(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.
----------------------------------------

(74) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U41^1(tt, V2) -> ISNATILIST(activate(V2)) at position [0] we obtained the following new rules [LPAR04]:

   (U41^1(tt, n__zeros) -> ISNATILIST(zeros),U41^1(tt, n__zeros) -> ISNATILIST(zeros))
   (U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1))),U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1))))
   (U41^1(tt, n__0) -> ISNATILIST(0),U41^1(tt, n__0) -> ISNATILIST(0))
   (U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))),U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))))
   (U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))),U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))))
   (U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)),U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)))
   (U41^1(tt, n__nil) -> ISNATILIST(nil),U41^1(tt, n__nil) -> ISNATILIST(nil))
   (U41^1(tt, x0) -> ISNATILIST(x0),U41^1(tt, x0) -> ISNATILIST(x0))


----------------------------------------

(75)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(zeros)
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   U41^1(tt, n__0) -> ISNATILIST(0)
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   U41^1(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.
----------------------------------------

(76) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)))
   (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__zeros), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__zeros), activate(y0)))


----------------------------------------

(77)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(zeros)
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   U41^1(tt, n__0) -> ISNATILIST(0)
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(78) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(79)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__zeros) -> ISNATILIST(zeros)
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   U41^1(tt, n__0) -> ISNATILIST(0)
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(80) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U41^1(tt, n__zeros) -> ISNATILIST(zeros) at position [0] we obtained the following new rules [LPAR04]:

   (U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)))
   (U41^1(tt, n__zeros) -> ISNATILIST(n__zeros),U41^1(tt, n__zeros) -> ISNATILIST(n__zeros))


----------------------------------------

(81)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   U41^1(tt, n__0) -> ISNATILIST(0)
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(82) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(83)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__0) -> ISNATILIST(0)
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(84) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U41^1(tt, n__0) -> ISNATILIST(0) at position [0] we obtained the following new rules [LPAR04]:

   (U41^1(tt, n__0) -> ISNATILIST(n__0),U41^1(tt, n__0) -> ISNATILIST(n__0))


----------------------------------------

(85)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   U41^1(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.
----------------------------------------

(86) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(87)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(88) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)),ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)))


----------------------------------------

(89)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__nil) -> ISNATILIST(nil)
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(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.
----------------------------------------

(90) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U41^1(tt, n__nil) -> ISNATILIST(nil) at position [0] we obtained the following new rules [LPAR04]:

   (U41^1(tt, n__nil) -> ISNATILIST(n__nil),U41^1(tt, n__nil) -> ISNATILIST(n__nil))


----------------------------------------

(91)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(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.
----------------------------------------

(92) DependencyGraphProof (EQUIVALENT)
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:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(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.
----------------------------------------

(94) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATILIST(n__cons(n__nil, y0)) -> U41^1(isNat(n__nil), activate(y0)),ISNATILIST(n__cons(n__nil, y0)) -> U41^1(isNat(n__nil), activate(y0)))


----------------------------------------

(95)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   ISNATILIST(n__cons(n__nil, y0)) -> U41^1(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.
----------------------------------------

(96) DependencyGraphProof (EQUIVALENT)
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)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(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.
----------------------------------------

(98) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(0, n__zeros)), activate(y0)))
   (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)))


----------------------------------------

(99)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(0, n__zeros)), activate(y0))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(100) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(101)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(102) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]:

   (U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)))
   (U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)))


----------------------------------------

(103)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(104) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]:

   (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(n__0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(n__0, n__zeros)), activate(y0)))


----------------------------------------

(105)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros))
   ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(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.
----------------------------------------

(106) DependencyGraphProof (EQUIVALENT)
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)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(108) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]:

   (U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)))


----------------------------------------

(109)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(110) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   U41^1(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( U41^1_2(x_1, x_2) ) = max{0, 2x_1 + 2x_2 - 2}
POL( ISNATILIST_1(x_1) ) = x_1
POL( U41_2(x_1, x_2) ) = 2
POL( U51_2(x_1, x_2) ) = x_2 + 1
POL( U61_2(x_1, x_2) ) = 1
POL( U71_3(x_1, ..., x_3) ) = 2
POL( U72_2(x_1, x_2) ) = 2
POL( U91_4(x_1, ..., x_4) ) = max{0, -2}
POL( U92_4(x_1, ..., x_4) ) = max{0, -2}
POL( U93_4(x_1, ..., x_4) ) = max{0, -2}
POL( cons_2(x_1, x_2) ) = 2x_2
POL( length_1(x_1) ) = 2
POL( s_1(x_1) ) = max{0, -2}
POL( take_2(x_1, x_2) ) = max{0, -2}
POL( U11_1(x_1) ) = 1
POL( isNatList_1(x_1) ) = 2x_1 + 1
POL( U21_1(x_1) ) = x_1
POL( isNat_1(x_1) ) = 1
POL( U31_1(x_1) ) = 2
POL( U42_1(x_1) ) = 2
POL( isNatIList_1(x_1) ) = 2
POL( U52_1(x_1) ) = 1
POL( U62_1(x_1) ) = 1
POL( n__take_2(x_1, x_2) ) = 0
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 0
POL( 0 ) = 0
POL( n__length_1(x_1) ) = 2
POL( n__s_1(x_1) ) = 0
POL( n__cons_2(x_1, x_2) ) = 2x_2
POL( n__nil ) = 0
POL( nil ) = 0
POL( U81_1(x_1) ) = max{0, -2}
POL( tt ) = 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__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)))
   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


----------------------------------------

(111)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__take(x0, x1), y1)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(112) QDPOrderProof (EQUIVALENT)
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)) -> U41^1(isNat(take(activate(x0), activate(x1))), activate(y1))
   ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))
   ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
Used ordering:  Polynomial Order [NEGPOLO,POLO] with Interpretation:

POL( U41^1_2(x_1, x_2) ) = 2x_2
POL( ISNATILIST_1(x_1) ) = 2x_1
POL( U41_2(x_1, x_2) ) = max{0, -2}
POL( U51_2(x_1, x_2) ) = max{0, -2}
POL( U61_2(x_1, x_2) ) = max{0, -2}
POL( U71_3(x_1, ..., x_3) ) = 1
POL( U72_2(x_1, x_2) ) = 1
POL( U91_4(x_1, ..., x_4) ) = x_2 + x_4 + 2
POL( U92_4(x_1, ..., x_4) ) = x_2 + x_4 + 2
POL( U93_4(x_1, ..., x_4) ) = x_2 + x_4 + 2
POL( cons_2(x_1, x_2) ) = x_1 + x_2
POL( length_1(x_1) ) = 1
POL( s_1(x_1) ) = 1
POL( take_2(x_1, x_2) ) = x_2 + 2
POL( U11_1(x_1) ) = max{0, -2}
POL( isNatList_1(x_1) ) = 1
POL( U21_1(x_1) ) = max{0, -2}
POL( isNat_1(x_1) ) = max{0, -2}
POL( U31_1(x_1) ) = max{0, -2}
POL( U42_1(x_1) ) = max{0, -2}
POL( isNatIList_1(x_1) ) = max{0, -2}
POL( U52_1(x_1) ) = max{0, -2}
POL( U62_1(x_1) ) = max{0, -2}
POL( n__take_2(x_1, x_2) ) = x_2 + 2
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 0
POL( 0 ) = 0
POL( n__length_1(x_1) ) = 1
POL( n__s_1(x_1) ) = 1
POL( n__cons_2(x_1, x_2) ) = x_1 + x_2
POL( n__nil ) = 0
POL( nil ) = 0
POL( U81_1(x_1) ) = max{0, -2}
POL( tt ) = 0

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__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__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)))
   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


----------------------------------------

(113)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(114) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   U41^1(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( U41^1_2(x_1, x_2) ) = 2x_2
POL( ISNATILIST_1(x_1) ) = x_1
POL( U41_2(x_1, x_2) ) = max{0, -2}
POL( U51_2(x_1, x_2) ) = max{0, -2}
POL( U61_2(x_1, x_2) ) = max{0, -2}
POL( U71_3(x_1, ..., x_3) ) = x_2 + 1
POL( U72_2(x_1, x_2) ) = 1
POL( U91_4(x_1, ..., x_4) ) = max{0, -2}
POL( U92_4(x_1, ..., x_4) ) = max{0, -2}
POL( U93_4(x_1, ..., x_4) ) = max{0, -2}
POL( cons_2(x_1, x_2) ) = 2x_2
POL( length_1(x_1) ) = x_1 + 2
POL( s_1(x_1) ) = 1
POL( take_2(x_1, x_2) ) = 0
POL( U11_1(x_1) ) = max{0, -2}
POL( isNatList_1(x_1) ) = 2
POL( U21_1(x_1) ) = max{0, -2}
POL( isNat_1(x_1) ) = max{0, -2}
POL( U31_1(x_1) ) = max{0, -2}
POL( U42_1(x_1) ) = max{0, -2}
POL( isNatIList_1(x_1) ) = 1
POL( U52_1(x_1) ) = max{0, -2}
POL( U62_1(x_1) ) = 0
POL( n__take_2(x_1, x_2) ) = max{0, -2}
POL( activate_1(x_1) ) = x_1
POL( n__zeros ) = 0
POL( zeros ) = 0
POL( n__0 ) = 0
POL( 0 ) = 0
POL( n__length_1(x_1) ) = x_1 + 2
POL( n__s_1(x_1) ) = 1
POL( n__cons_2(x_1, x_2) ) = 2x_2
POL( n__nil ) = 0
POL( nil ) = 0
POL( U81_1(x_1) ) = max{0, -2}
POL( tt ) = 0

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__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__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)))
   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


----------------------------------------

(115)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__take(x0, x1)) -> ISNATILIST(take(activate(x0), activate(x1)))
   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(116) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   U41^1(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(U41^1(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(tt) =  	[[2A]]
>>>

   <<<
 POL(n__take(x_1, x_2)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(ISNATILIST(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(take(x_1, x_2)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(activate(x_1)) =  	[[1A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__cons(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(isNat(x_1)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(cons(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(n__0) =  	[[0A]]
>>>

   <<<
 POL(n__zeros) =  	[[0A]]
>>>

   <<<
 POL(0) =  	[[0A]]
>>>

   <<<
 POL(zeros) =  	[[1A]]
>>>

   <<<
 POL(n__length(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(length(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__s(x_1)) =  	[[3A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(s(x_1)) =  	[[3A]] 	 +  	[[1A]] 	* 	x_1
>>>

   <<<
 POL(n__nil) =  	[[2A]]
>>>

   <<<
 POL(nil) =  	[[2A]]
>>>

   <<<
 POL(U81(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(isNatIList(x_1)) =  	[[2A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U91(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3 	 +  	[[0A]] 	* 	x_4
>>>

   <<<
 POL(U11(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(isNatList(x_1)) =  	[[1A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U21(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U71(x_1, x_2, x_3)) =  	[[-I]] 	 +  	[[1A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[0A]] 	* 	x_3
>>>

   <<<
 POL(U51(x_1, x_2)) =  	[[1A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(U61(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(U62(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U31(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U41(x_1, x_2)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(U42(x_1)) =  	[[2A]] 	 +  	[[-I]] 	* 	x_1
>>>

   <<<
 POL(U52(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(U72(x_1, x_2)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(U92(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3 	 +  	[[0A]] 	* 	x_4
>>>

   <<<
 POL(U93(x_1, x_2, x_3, x_4)) =  	[[3A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3 	 +  	[[0A]] 	* 	x_4
>>>


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__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


----------------------------------------

(117)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))
   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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.
----------------------------------------

(118) QDPOrderProof (EQUIVALENT)
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)) -> U41^1(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(x_1)) =  	[[0]] 	 +  	[[1, 0]] 	* 	x_1
>>>

   <<<
 POL(n__cons(x_1, x_2)) =  	[[0], [1]] 	 +  	[[1, 1], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U41^1(x_1, x_2)) =  	[[0]] 	 +  	[[0, 0]] 	* 	x_1 	 +  	[[1, 0]] 	* 	x_2
>>>

   <<<
 POL(isNat(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(cons(x_1, x_2)) =  	[[0], [1]] 	 +  	[[1, 1], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(activate(x_1)) =  	[[0], [0]] 	 +  	[[1, 0], [0, 1]] 	* 	x_1
>>>

   <<<
 POL(tt) =  	[[0], [0]]
>>>

   <<<
 POL(n__0) =  	[[0], [0]]
>>>

   <<<
 POL(n__zeros) =  	[[0], [1]]
>>>

   <<<
 POL(0) =  	[[0], [0]]
>>>

   <<<
 POL(zeros) =  	[[0], [1]]
>>>

   <<<
 POL(n__take(x_1, x_2)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(take(x_1, x_2)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(n__length(x_1)) =  	[[0], [1]] 	 +  	[[1, 1], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(length(x_1)) =  	[[0], [1]] 	 +  	[[1, 1], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(n__s(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(s(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(n__nil) =  	[[0], [0]]
>>>

   <<<
 POL(nil) =  	[[0], [0]]
>>>

   <<<
 POL(U11(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(isNatList(x_1)) =  	[[1], [1]] 	 +  	[[1, 0], [1, 1]] 	* 	x_1
>>>

   <<<
 POL(U21(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U71(x_1, x_2, x_3)) =  	[[1], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2 	 +  	[[1, 1], [0, 0]] 	* 	x_3
>>>

   <<<
 POL(U51(x_1, x_2)) =  	[[1], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U61(x_1, x_2)) =  	[[1], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U62(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(isNatIList(x_1)) =  	[[1], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U31(x_1)) =  	[[1], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U41(x_1, x_2)) =  	[[1], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U42(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U52(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U72(x_1, x_2)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[0, 0], [0, 0]] 	* 	x_2
>>>

   <<<
 POL(U81(x_1)) =  	[[0], [0]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1
>>>

   <<<
 POL(U91(x_1, x_2, x_3, x_4)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3 	 +  	[[1, 1], [0, 0]] 	* 	x_4
>>>

   <<<
 POL(U92(x_1, x_2, x_3, x_4)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3 	 +  	[[1, 1], [0, 0]] 	* 	x_4
>>>

   <<<
 POL(U93(x_1, x_2, x_3, x_4)) =  	[[0], [1]] 	 +  	[[0, 0], [0, 0]] 	* 	x_1 	 +  	[[1, 0], [0, 0]] 	* 	x_2 	 +  	[[0, 0], [0, 0]] 	* 	x_3 	 +  	[[1, 1], [0, 0]] 	* 	x_4
>>>


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__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)))
   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


----------------------------------------

(119)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))
   ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))
   U41^1(tt, x0) -> ISNATILIST(x0)
   ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))
   U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))
   U41^1(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) NonTerminationLoopProof (COMPLETE)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

s = U41^1(isNat(n__0), activate(n__zeros)) evaluates to  t =U41^1(isNat(n__0), activate(n__zeros))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [ ]
* Semiunifier: [ ]

--------------------------------------------------------------------------------
Rewriting sequence

U41^1(isNat(n__0), activate(n__zeros)) -> U41^1(isNat(n__0), n__zeros)
with rule activate(X) -> X at position [1] and matcher [X / n__zeros]

U41^1(isNat(n__0), n__zeros) -> U41^1(tt, n__zeros)
with rule isNat(n__0) -> tt at position [0] and matcher [ ]

U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros))
with rule U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) at position [] and matcher [ ]

ISNATILIST(n__cons(n__0, n__zeros)) -> U41^1(isNat(n__0), activate(n__zeros))
with rule ISNATILIST(n__cons(x0, y1)) -> U41^1(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.




----------------------------------------

(121)
NO