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


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 remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
INCR(x1)  =  INCR(x1)
cons(x1, x2)  =  x2
ACTIVATE(x1)  =  x1
n__incr(x1)  =  n__incr(x1)
n__take(x1, x2)  =  n__take(x2)
TAKE(x1, x2)  =  TAKE(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)

Lexicographic path order with status [LPO].
Precedence:
nincr1 > INCR1 > TAKE1
ntake1 > TAKE1
s1 > TAKE1
nzip2 > ZIP2 > TAKE1
nrepItems1 > REPITEMS1 > TAKE1

Status:
INCR1: [1]
nincr1: [1]
ntake1: [1]
TAKE1: [1]
s1: [1]
nzip2: [1,2]
ZIP2: [1,2]
nrepItems1: [1]
REPITEMS1: [1]

The following usable rules [FROCOS05] were oriented: none

(7) Obligation:

Q DP problem:
P is empty.
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) PisEmptyProof (EQUIVALENT transformation)

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

(9) TRUE

(10) Obligation:

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

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.