Termination w.r.t. Q proof of /tmp/tmpg1ksAy/Ex5_DLMMU04

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

0 QTRS

↳1 QTRSRRRProof (⇔)

↳2 QTRS

↳3 QTRSRRRProof (⇔)

↳4 QTRS

↳5 QTRSRRRProof (⇔)

↳6 QTRS

↳7 DependencyPairsProof (⇔)

↳8 QDP

↳9 DependencyGraphProof (⇔)

↳10 AND

  ↳11 QDP

    ↳12 UsableRulesProof (⇔)

    ↳13 QDP

    ↳14 QDPSizeChangeProof (⇔)

    ↳15 TRUE

  ↳16 QDP

    ↳17 UsableRulesProof (⇔)

    ↳18 QDP

    ↳19 QDPSizeChangeProof (⇔)

    ↳20 TRUE

  ↳21 QDP

    ↳22 UsableRulesProof (⇔)

    ↳23 QDP

    ↳24 QDPSizeChangeProof (⇔)

    ↳25 TRUE

  ↳26 QDP

    ↳27 UsableRulesProof (⇔)

    ↳28 QDP

    ↳29 QDPSizeChangeProof (⇔)

    ↳30 TRUE

  ↳31 QDP

    ↳32 UsableRulesProof (⇔)

    ↳33 QDP

    ↳34 QDPSizeChangeProof (⇔)

    ↳35 TRUE

  ↳36 QDP

    ↳37 UsableRulesProof (⇔)

    ↳38 QDP

    ↳39 QDPSizeChangeProof (⇔)

    ↳40 TRUE

  ↳41 QDP

    ↳42 UsableRulesProof (⇔)

    ↳43 QDP

    ↳44 QDPSizeChangeProof (⇔)

    ↳45 TRUE

  ↳46 QDP

    ↳47 UsableRulesProof (⇔)

    ↳48 QDP

    ↳49 QDPSizeChangeProof (⇔)

    ↳50 TRUE

  ↳51 QDP

    ↳52 MRRProof (⇔)

    ↳53 QDP

    ↳54 MRRProof (⇔)

    ↳55 QDP

    ↳56 MRRProof (⇔)

    ↳57 QDP

    ↳58 MRRProof (⇔)

    ↳59 QDP

    ↳60 QDPOrderProof (⇔)

    ↳61 QDP

    ↳62 QDPOrderProof (⇔)

    ↳63 QDP

    ↳64 DependencyGraphProof (⇔)

    ↳65 QDP

    ↳66 QDPOrderProof (⇔)

    ↳67 QDP

    ↳68 QDPOrderProof (⇔)

    ↳69 QDP

    ↳70 DependencyGraphProof (⇔)

    ↳71 QDP

    ↳72 QDPOrderProof (⇔)

    ↳73 QDP

    ↳74 QDPOrderProof (⇔)

    ↳75 QDP

    ↳76 QDPOrderProof (⇔)

    ↳77 QDP

    ↳78 QDPOrderProof (⇔)

    ↳79 QDP

    ↳80 QDPOrderProof (⇔)

    ↳81 QDP

    ↳82 DependencyGraphProof (⇔)

    ↳83 QDP

    ↳84 UsableRulesProof (⇔)

    ↳85 QDP

    ↳86 QDPSizeChangeProof (⇔)

    ↳87 TRUE

(0) Obligation:

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

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(0, XS)) → mark(nil)
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(nil, XS)) → mark(nil)
active(zip(X, nil)) → mark(nil)
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(tail(cons(X, XS))) → mark(XS)
active(repItems(nil)) → mark(nil)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

Q is empty.

(1) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = 2·x₁ + x₂
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 2·x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = 2 + 2·x₁
POL(take(x₁, x₂)) = x₁ + 2·x₂
POL(zip(x₁, x₂)) = 2 + x₁ + x₂

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

active(zip(nil, XS)) → mark(nil)
active(zip(X, nil)) → mark(nil)
active(tail(cons(X, XS))) → mark(XS)

(2) Obligation:

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

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(0, XS)) → mark(nil)
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(nil)) → mark(nil)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

Q is empty.

(3) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁ + x₂
POL(incr(x₁)) = 2·x₁
POL(mark(x₁)) = x₁
POL(nil) = 2
POL(oddNs) = 0
POL(pair(x₁, x₂)) = 2·x₁ + 2·x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 2·x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = 2 + x₁ + x₂
POL(zip(x₁, x₂)) = 2·x₁ + 2·x₂

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

active(repItems(nil)) → mark(nil)

(4) Obligation:

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

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(0, XS)) → mark(nil)
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

Q is empty.

(5) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = 2·x₁ + x₂
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 1
POL(oddNs) = 0
POL(pair(x₁, x₂)) = 2·x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 2·x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = 2 + 2·x₁ + 2·x₂
POL(zip(x₁, x₂)) = 2·x₁ + 2·x₂

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

active(take(0, XS)) → mark(nil)

(6) Obligation:

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

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

Q is empty.

(7) DependencyPairsProof (EQUIVALENT transformation)

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

(8) Obligation:

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

ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
ACTIVE(pairNs) → CONS(0, incr(oddNs))
ACTIVE(pairNs) → INCR(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
ACTIVE(oddNs) → INCR(pairNs)
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
ACTIVE(incr(cons(X, XS))) → CONS(s(X), incr(XS))
ACTIVE(incr(cons(X, XS))) → S(X)
ACTIVE(incr(cons(X, XS))) → INCR(XS)
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
ACTIVE(take(s(N), cons(X, XS))) → CONS(X, take(N, XS))
ACTIVE(take(s(N), cons(X, XS))) → TAKE(N, XS)
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → CONS(pair(X, Y), zip(XS, YS))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → PAIR(X, Y)
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → ZIP(XS, YS)
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
ACTIVE(repItems(cons(X, XS))) → CONS(X, cons(X, repItems(XS)))
ACTIVE(repItems(cons(X, XS))) → CONS(X, repItems(XS))
ACTIVE(repItems(cons(X, XS))) → REPITEMS(XS)
MARK(pairNs) → ACTIVE(pairNs)
MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
MARK(cons(X1, X2)) → CONS(mark(X1), X2)
MARK(cons(X1, X2)) → MARK(X1)
MARK(0) → ACTIVE(0)
MARK(incr(X)) → ACTIVE(incr(mark(X)))
MARK(incr(X)) → INCR(mark(X))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
MARK(s(X)) → ACTIVE(s(mark(X)))
MARK(s(X)) → S(mark(X))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
MARK(take(X1, X2)) → TAKE(mark(X1), mark(X2))
MARK(take(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(nil) → ACTIVE(nil)
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → ZIP(mark(X1), mark(X2))
MARK(zip(X1, X2)) → MARK(X1)
MARK(zip(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → PAIR(mark(X1), mark(X2))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(tail(X)) → ACTIVE(tail(mark(X)))
MARK(tail(X)) → TAIL(mark(X))
MARK(tail(X)) → MARK(X)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))
MARK(repItems(X)) → REPITEMS(mark(X))
MARK(repItems(X)) → MARK(X)
CONS(mark(X1), X2) → CONS(X1, X2)
CONS(X1, mark(X2)) → CONS(X1, X2)
CONS(active(X1), X2) → CONS(X1, X2)
CONS(X1, active(X2)) → CONS(X1, X2)
INCR(mark(X)) → INCR(X)
INCR(active(X)) → INCR(X)
S(mark(X)) → S(X)
S(active(X)) → S(X)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(active(X1), X2) → TAKE(X1, X2)
TAKE(X1, active(X2)) → TAKE(X1, X2)
ZIP(mark(X1), X2) → ZIP(X1, X2)
ZIP(X1, mark(X2)) → ZIP(X1, X2)
ZIP(active(X1), X2) → ZIP(X1, X2)
ZIP(X1, active(X2)) → ZIP(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)
PAIR(X1, mark(X2)) → PAIR(X1, X2)
PAIR(active(X1), X2) → PAIR(X1, X2)
PAIR(X1, active(X2)) → PAIR(X1, X2)
TAIL(mark(X)) → TAIL(X)
TAIL(active(X)) → TAIL(X)
REPITEMS(mark(X)) → REPITEMS(X)
REPITEMS(active(X)) → REPITEMS(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(9) DependencyGraphProof (EQUIVALENT transformation)

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

(10) Complex Obligation (AND)

(11) Obligation:

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

REPITEMS(active(X)) → REPITEMS(X)
REPITEMS(mark(X)) → REPITEMS(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(12) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(13) Obligation:

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

REPITEMS(active(X)) → REPITEMS(X)
REPITEMS(mark(X)) → REPITEMS(X)

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

(14) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

REPITEMS(active(X)) → REPITEMS(X)
The graph contains the following edges 1 > 1
REPITEMS(mark(X)) → REPITEMS(X)
The graph contains the following edges 1 > 1

(15) TRUE

(16) Obligation:

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

TAIL(active(X)) → TAIL(X)
TAIL(mark(X)) → TAIL(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(17) UsableRulesProof (EQUIVALENT transformation)

(18) Obligation:

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

TAIL(active(X)) → TAIL(X)
TAIL(mark(X)) → TAIL(X)

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

(19) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

TAIL(active(X)) → TAIL(X)
The graph contains the following edges 1 > 1
TAIL(mark(X)) → TAIL(X)
The graph contains the following edges 1 > 1

(20) TRUE

(21) Obligation:

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

PAIR(X1, mark(X2)) → PAIR(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)
PAIR(active(X1), X2) → PAIR(X1, X2)
PAIR(X1, active(X2)) → PAIR(X1, X2)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(22) UsableRulesProof (EQUIVALENT transformation)

(23) Obligation:

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

PAIR(X1, mark(X2)) → PAIR(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)
PAIR(active(X1), X2) → PAIR(X1, X2)
PAIR(X1, active(X2)) → PAIR(X1, X2)

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

(24) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

PAIR(X1, mark(X2)) → PAIR(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2
PAIR(mark(X1), X2) → PAIR(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
PAIR(active(X1), X2) → PAIR(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
PAIR(X1, active(X2)) → PAIR(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2

(25) TRUE

(26) Obligation:

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

ZIP(X1, mark(X2)) → ZIP(X1, X2)
ZIP(mark(X1), X2) → ZIP(X1, X2)
ZIP(active(X1), X2) → ZIP(X1, X2)
ZIP(X1, active(X2)) → ZIP(X1, X2)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(27) UsableRulesProof (EQUIVALENT transformation)

(28) Obligation:

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

ZIP(X1, mark(X2)) → ZIP(X1, X2)
ZIP(mark(X1), X2) → ZIP(X1, X2)
ZIP(active(X1), X2) → ZIP(X1, X2)
ZIP(X1, active(X2)) → ZIP(X1, X2)

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

(29) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

ZIP(X1, mark(X2)) → ZIP(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2
ZIP(mark(X1), X2) → ZIP(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
ZIP(active(X1), X2) → ZIP(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
ZIP(X1, active(X2)) → ZIP(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2

(30) TRUE

(31) Obligation:

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

TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(active(X1), X2) → TAKE(X1, X2)
TAKE(X1, active(X2)) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(32) UsableRulesProof (EQUIVALENT transformation)

(33) Obligation:

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

TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(active(X1), X2) → TAKE(X1, X2)
TAKE(X1, active(X2)) → TAKE(X1, X2)

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

(34) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

TAKE(X1, mark(X2)) → TAKE(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2
TAKE(mark(X1), X2) → TAKE(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
TAKE(active(X1), X2) → TAKE(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
TAKE(X1, active(X2)) → TAKE(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2

(35) TRUE

(36) Obligation:

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

S(active(X)) → S(X)
S(mark(X)) → S(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(37) UsableRulesProof (EQUIVALENT transformation)

(38) Obligation:

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

S(active(X)) → S(X)
S(mark(X)) → S(X)

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

(39) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

S(active(X)) → S(X)
The graph contains the following edges 1 > 1
S(mark(X)) → S(X)
The graph contains the following edges 1 > 1

(40) TRUE

(41) Obligation:

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

INCR(active(X)) → INCR(X)
INCR(mark(X)) → INCR(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(42) UsableRulesProof (EQUIVALENT transformation)

(43) Obligation:

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

INCR(active(X)) → INCR(X)
INCR(mark(X)) → INCR(X)

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

(44) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

INCR(active(X)) → INCR(X)
The graph contains the following edges 1 > 1
INCR(mark(X)) → INCR(X)
The graph contains the following edges 1 > 1

(45) TRUE

(46) Obligation:

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

CONS(X1, mark(X2)) → CONS(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)
CONS(active(X1), X2) → CONS(X1, X2)
CONS(X1, active(X2)) → CONS(X1, X2)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(47) UsableRulesProof (EQUIVALENT transformation)

(48) Obligation:

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

CONS(X1, mark(X2)) → CONS(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)
CONS(active(X1), X2) → CONS(X1, X2)
CONS(X1, active(X2)) → CONS(X1, X2)

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

(49) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

CONS(X1, mark(X2)) → CONS(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2
CONS(mark(X1), X2) → CONS(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
CONS(active(X1), X2) → CONS(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
CONS(X1, active(X2)) → CONS(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2

(50) TRUE

(51) Obligation:

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

MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
MARK(s(X)) → ACTIVE(s(mark(X)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(take(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → MARK(X1)
MARK(zip(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(tail(X)) → ACTIVE(tail(mark(X)))
MARK(tail(X)) → MARK(X)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))
MARK(repItems(X)) → MARK(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(52) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

MARK(tail(X)) → MARK(X)

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = 2·x₁
POL(MARK(x₁)) = 2·x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = 2·x₁ + x₂
POL(incr(x₁)) = 2·x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = 2·x₁ + 2·x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 2·x₁
POL(s(x₁)) = 2·x₁
POL(tail(x₁)) = 2 + 2·x₁
POL(take(x₁, x₂)) = x₁ + x₂
POL(zip(x₁, x₂)) = 2·x₁ + 2·x₂

(53) Obligation:

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

MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
MARK(s(X)) → ACTIVE(s(mark(X)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(take(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → MARK(X1)
MARK(zip(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(tail(X)) → ACTIVE(tail(mark(X)))
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))
MARK(repItems(X)) → MARK(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(54) MRRProof (EQUIVALENT transformation)

MARK(take(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁ + x₂
POL(incr(x₁)) = 2·x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = 2·x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 2·x₁
POL(s(x₁)) = 2·x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + 2·x₂
POL(zip(x₁, x₂)) = 2·x₁ + 2·x₂

(55) Obligation:

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

MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
MARK(s(X)) → ACTIVE(s(mark(X)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → MARK(X1)
MARK(zip(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(tail(X)) → ACTIVE(tail(mark(X)))
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))
MARK(repItems(X)) → MARK(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(56) MRRProof (EQUIVALENT transformation)

MARK(repItems(X)) → MARK(X)

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁ + x₂
POL(incr(x₁)) = 2·x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 1 + 2·x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = 2·x₁ + x₂
POL(zip(x₁, x₂)) = x₁ + x₂

(57) Obligation:

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

MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
MARK(s(X)) → ACTIVE(s(mark(X)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → MARK(X1)
MARK(zip(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(tail(X)) → ACTIVE(tail(mark(X)))
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(58) MRRProof (EQUIVALENT transformation)

MARK(zip(X1, X2)) → MARK(X1)
MARK(zip(X1, X2)) → MARK(X2)

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = 2·x₁
POL(MARK(x₁)) = 2·x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = 2·x₁ + x₂
POL(incr(x₁)) = 2·x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 2·x₁
POL(s(x₁)) = 2·x₁
POL(tail(x₁)) = 2·x₁
POL(take(x₁, x₂)) = 2·x₁ + x₂
POL(zip(x₁, x₂)) = 1 + 2·x₁ + x₂

(59) Obligation:

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

MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
MARK(s(X)) → ACTIVE(s(mark(X)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(tail(X)) → ACTIVE(tail(mark(X)))
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(60) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
MARK(s(X)) → ACTIVE(s(mark(X)))
MARK(pair(X1, X2)) → ACTIVE(pair(mark(X1), mark(X2)))
MARK(tail(X)) → ACTIVE(tail(mark(X)))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = 1
POL(active(x₁)) = 0
POL(cons(x₁, x₂)) = 0
POL(incr(x₁)) = 1
POL(mark(x₁)) = 0
POL(nil) = 0
POL(oddNs) = 1
POL(pair(x₁, x₂)) = 0
POL(pairNs) = 1
POL(repItems(x₁)) = 1
POL(s(x₁)) = 0
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = 1
POL(zip(x₁, x₂)) = 1

The following usable rules [FROCOS05] were oriented:

cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)

(61) Obligation:

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

ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(oddNs) → MARK(incr(pairNs))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(62) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(oddNs) → MARK(incr(pairNs))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 1
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = x₂
POL(zip(x₁, x₂)) = x₁ + x₂

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))

(63) Obligation:

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

ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(incr(X)) → MARK(X)
MARK(oddNs) → ACTIVE(oddNs)
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(64) DependencyGraphProof (EQUIVALENT transformation)

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

(65) Obligation:

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

MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))
ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(66) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(repItems(cons(X, XS))) → MARK(cons(X, cons(X, repItems(XS))))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = 1 + x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = x₂
POL(zip(x₁, x₂)) = x₁ + x₂

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))

(67) Obligation:

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

MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(68) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(pairNs) → MARK(cons(0, incr(oddNs)))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 1
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 1
POL(repItems(x₁)) = x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = x₂
POL(zip(x₁, x₂)) = x₁ + x₂

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))

(69) Obligation:

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

MARK(cons(X1, X2)) → MARK(X1)
MARK(pairNs) → ACTIVE(pairNs)
MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(70) DependencyGraphProof (EQUIVALENT transformation)

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

(71) Obligation:

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

MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(72) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(take(s(N), cons(X, XS))) → MARK(cons(X, take(N, XS)))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 1
POL(oddNs) = 1
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 1
POL(repItems(x₁)) = x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₂
POL(zip(x₁, x₂)) = x₁ + x₂

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))

(73) Obligation:

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

MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(74) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(zip(cons(X, XS), cons(Y, YS))) → MARK(cons(pair(X, Y), zip(XS, YS)))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = x₂
POL(zip(x₁, x₂)) = 1 + x₁ + x₂

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))

(75) Obligation:

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

MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(76) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(pair(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 1
POL(pair(x₁, x₂)) = 1 + x₁ + x₂
POL(pairNs) = 0
POL(repItems(x₁)) = x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = x₂
POL(zip(x₁, x₂)) = 1 + x₁ + x₂

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))

(77) Obligation:

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

MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)
MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(78) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(take(X1, X2)) → ACTIVE(take(mark(X1), mark(X2)))
MARK(zip(X1, X2)) → ACTIVE(zip(mark(X1), mark(X2)))
MARK(repItems(X)) → ACTIVE(repItems(mark(X)))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = 1
POL(active(x₁)) = 0
POL(cons(x₁, x₂)) = 0
POL(incr(x₁)) = 1
POL(mark(x₁)) = 0
POL(nil) = 0
POL(oddNs) = 0
POL(pair(x₁, x₂)) = 0
POL(pairNs) = 0
POL(repItems(x₁)) = 0
POL(s(x₁)) = 0
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(zip(x₁, x₂)) = 0

The following usable rules [FROCOS05] were oriented:

incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)

(79) Obligation:

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

MARK(incr(X)) → ACTIVE(incr(mark(X)))
ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(incr(X)) → MARK(X)
MARK(s(X)) → MARK(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(80) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(incr(cons(X, XS))) → MARK(cons(s(X), incr(XS)))
MARK(incr(X)) → MARK(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0
POL(ACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(active(x₁)) = x₁
POL(cons(x₁, x₂)) = x₁
POL(incr(x₁)) = 1 + x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(oddNs) = 1
POL(pair(x₁, x₂)) = 0
POL(pairNs) = 0
POL(repItems(x₁)) = 1 + x₁
POL(s(x₁)) = x₁
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = x₁ + x₂
POL(zip(x₁, x₂)) = x₁

The following usable rules [FROCOS05] were oriented:

mark(nil) → active(nil)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
incr(active(X)) → incr(X)
incr(mark(X)) → incr(X)
mark(0) → active(0)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
repItems(active(X)) → repItems(X)
repItems(mark(X)) → repItems(X)
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(repItems(X)) → active(repItems(mark(X)))
mark(oddNs) → active(oddNs)
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
mark(incr(X)) → active(incr(mark(X)))
mark(s(X)) → active(s(mark(X)))
active(pairNs) → mark(cons(0, incr(oddNs)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
mark(tail(X)) → active(tail(mark(X)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
active(oddNs) → mark(incr(pairNs))
take(X1, mark(X2)) → take(X1, X2)
take(mark(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)

(81) Obligation:

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

MARK(incr(X)) → ACTIVE(incr(mark(X)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(s(X)) → MARK(X)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(82) DependencyGraphProof (EQUIVALENT transformation)

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:

MARK(s(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)

The TRS R consists of the following rules:

active(pairNs) → mark(cons(0, incr(oddNs)))
active(oddNs) → mark(incr(pairNs))
active(incr(cons(X, XS))) → mark(cons(s(X), incr(XS)))
active(take(s(N), cons(X, XS))) → mark(cons(X, take(N, XS)))
active(zip(cons(X, XS), cons(Y, YS))) → mark(cons(pair(X, Y), zip(XS, YS)))
active(repItems(cons(X, XS))) → mark(cons(X, cons(X, repItems(XS))))
mark(pairNs) → active(pairNs)
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(0) → active(0)
mark(incr(X)) → active(incr(mark(X)))
mark(oddNs) → active(oddNs)
mark(s(X)) → active(s(mark(X)))
mark(take(X1, X2)) → active(take(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(zip(X1, X2)) → active(zip(mark(X1), mark(X2)))
mark(pair(X1, X2)) → active(pair(mark(X1), mark(X2)))
mark(tail(X)) → active(tail(mark(X)))
mark(repItems(X)) → active(repItems(mark(X)))
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
incr(mark(X)) → incr(X)
incr(active(X)) → incr(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
take(mark(X1), X2) → take(X1, X2)
take(X1, mark(X2)) → take(X1, X2)
take(active(X1), X2) → take(X1, X2)
take(X1, active(X2)) → take(X1, X2)
zip(mark(X1), X2) → zip(X1, X2)
zip(X1, mark(X2)) → zip(X1, X2)
zip(active(X1), X2) → zip(X1, X2)
zip(X1, active(X2)) → zip(X1, X2)
pair(mark(X1), X2) → pair(X1, X2)
pair(X1, mark(X2)) → pair(X1, X2)
pair(active(X1), X2) → pair(X1, X2)
pair(X1, active(X2)) → pair(X1, X2)
tail(mark(X)) → tail(X)
tail(active(X)) → tail(X)
repItems(mark(X)) → repItems(X)
repItems(active(X)) → repItems(X)

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

(84) UsableRulesProof (EQUIVALENT transformation)

(85) Obligation:

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

MARK(s(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)

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

(86) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

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

MARK(s(X)) → MARK(X)
The graph contains the following edges 1 > 1
MARK(cons(X1, X2)) → MARK(X1)
The graph contains the following edges 1 > 1