(0) Obligation:

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

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

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

(2) Obligation:

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

PAIRNSCONS(0, n__incr(oddNs))
PAIRNSODDNS
ODDNSINCR(pairNs)
ODDNSPAIRNS
INCR(cons(X, XS)) → CONS(s(X), n__incr(activate(XS)))
INCR(cons(X, XS)) → ACTIVATE(XS)
TAKE(s(N), cons(X, XS)) → CONS(X, n__take(N, activate(XS)))
TAKE(s(N), cons(X, XS)) → ACTIVATE(XS)
ZIP(cons(X, XS), cons(Y, YS)) → CONS(pair(X, Y), n__zip(activate(XS), activate(YS)))
ZIP(cons(X, XS), cons(Y, YS)) → ACTIVATE(XS)
ZIP(cons(X, XS), cons(Y, YS)) → ACTIVATE(YS)
TAIL(cons(X, XS)) → ACTIVATE(XS)
REPITEMS(cons(X, XS)) → CONS(X, n__cons(X, n__repItems(activate(XS))))
REPITEMS(cons(X, XS)) → ACTIVATE(XS)
ACTIVATE(n__incr(X)) → INCR(X)
ACTIVATE(n__take(X1, X2)) → TAKE(X1, X2)
ACTIVATE(n__zip(X1, X2)) → ZIP(X1, X2)
ACTIVATE(n__cons(X1, X2)) → CONS(X1, X2)
ACTIVATE(n__repItems(X)) → REPITEMS(X)

The TRS R consists of the following rules:

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

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

(3) DependencyGraphProof (EQUIVALENT transformation)

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

(4) Complex Obligation (AND)

(5) Obligation:

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

INCR(cons(X, XS)) → ACTIVATE(XS)
ACTIVATE(n__incr(X)) → INCR(X)
ACTIVATE(n__take(X1, X2)) → TAKE(X1, X2)
TAKE(s(N), cons(X, XS)) → ACTIVATE(XS)
ACTIVATE(n__zip(X1, X2)) → ZIP(X1, X2)
ZIP(cons(X, XS), cons(Y, YS)) → ACTIVATE(XS)
ACTIVATE(n__repItems(X)) → REPITEMS(X)
REPITEMS(cons(X, XS)) → ACTIVATE(XS)
ZIP(cons(X, XS), cons(Y, YS)) → ACTIVATE(YS)

The TRS R consists of the following rules:

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

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

(6) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


TAKE(s(N), cons(X, XS)) → ACTIVATE(XS)
ACTIVATE(n__zip(X1, X2)) → ZIP(X1, X2)
ZIP(cons(X, XS), cons(Y, YS)) → ACTIVATE(XS)
ACTIVATE(n__repItems(X)) → REPITEMS(X)
REPITEMS(cons(X, XS)) → ACTIVATE(XS)
ZIP(cons(X, XS), cons(Y, YS)) → ACTIVATE(YS)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
INCR(x1)  =  x1
cons(x1, x2)  =  x2
ACTIVATE(x1)  =  x1
n__incr(x1)  =  x1
n__take(x1, x2)  =  n__take(x1, x2)
TAKE(x1, x2)  =  TAKE(x1, x2)
s(x1)  =  s(x1)
n__zip(x1, x2)  =  n__zip(x1, x2)
ZIP(x1, x2)  =  ZIP(x1, x2)
n__repItems(x1)  =  n__repItems(x1)
REPITEMS(x1)  =  REPITEMS(x1)
pairNs  =  pairNs
0  =  0
oddNs  =  oddNs
incr(x1)  =  x1
activate(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
nil  =  nil
zip(x1, x2)  =  zip(x1, x2)
pair(x1, x2)  =  pair(x2)
tail(x1)  =  tail(x1)
repItems(x1)  =  repItems(x1)
n__cons(x1, x2)  =  x2

Lexicographic Path Order [LPO].
Precedence:
[ntake2, TAKE2, take2] > [0, nil]
s1 > [0, nil]
[nzip2, zip2] > ZIP2 > [0, nil]
[nzip2, zip2] > pair1 > [0, nil]
[nrepItems1, repItems1] > REPITEMS1 > [0, nil]
[pairNs, oddNs] > [0, nil]
tail1 > [0, nil]


The following usable rules [FROCOS05] were oriented:

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

(7) Obligation:

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

INCR(cons(X, XS)) → ACTIVATE(XS)
ACTIVATE(n__incr(X)) → INCR(X)
ACTIVATE(n__take(X1, X2)) → TAKE(X1, X2)

The TRS R consists of the following rules:

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

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

(8) DependencyGraphProof (EQUIVALENT transformation)

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

(9) Obligation:

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

ACTIVATE(n__incr(X)) → INCR(X)
INCR(cons(X, XS)) → ACTIVATE(XS)

The TRS R consists of the following rules:

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

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

(10) Obligation:

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

PAIRNSODDNS
ODDNSPAIRNS

The TRS R consists of the following rules:

pairNscons(0, n__incr(oddNs))
oddNsincr(pairNs)
incr(cons(X, XS)) → cons(s(X), n__incr(activate(XS)))
take(0, XS) → nil
take(s(N), cons(X, XS)) → cons(X, n__take(N, activate(XS)))
zip(nil, XS) → nil
zip(X, nil) → nil
zip(cons(X, XS), cons(Y, YS)) → cons(pair(X, Y), n__zip(activate(XS), activate(YS)))
tail(cons(X, XS)) → activate(XS)
repItems(nil) → nil
repItems(cons(X, XS)) → cons(X, n__cons(X, n__repItems(activate(XS))))
incr(X) → n__incr(X)
take(X1, X2) → n__take(X1, X2)
zip(X1, X2) → n__zip(X1, X2)
cons(X1, X2) → n__cons(X1, X2)
repItems(X) → n__repItems(X)
activate(n__incr(X)) → incr(X)
activate(n__take(X1, X2)) → take(X1, X2)
activate(n__zip(X1, X2)) → zip(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__repItems(X)) → repItems(X)
activate(X) → X

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