Termination w.r.t. Q proof of /tmp/tmplfiVEs/ExIntrod_GM04

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

0 QTRS

↳1 DependencyPairsProof (⇔)

↳2 QDP

↳3 DependencyGraphProof (⇔)

↳4 AND

  ↳5 QDP

    ↳6 QDPOrderProof (⇔)

    ↳7 QDP

    ↳8 PisEmptyProof (⇔)

    ↳9 TRUE

  ↳10 QDP

    ↳11 QDPOrderProof (⇔)

    ↳12 QDP

    ↳13 PisEmptyProof (⇔)

    ↳14 TRUE

  ↳15 QDP

    ↳16 QDPOrderProof (⇔)

    ↳17 QDP

    ↳18 QDPOrderProof (⇔)

    ↳19 QDP

    ↳20 PisEmptyProof (⇔)

    ↳21 TRUE

  ↳22 QDP

    ↳23 QDPOrderProof (⇔)

    ↳24 QDP

    ↳25 QDPOrderProof (⇔)

    ↳26 QDP

    ↳27 PisEmptyProof (⇔)

    ↳28 TRUE

  ↳29 QDP

    ↳30 QDPOrderProof (⇔)

    ↳31 QDP

    ↳32 QDPOrderProof (⇔)

    ↳33 QDP

    ↳34 PisEmptyProof (⇔)

    ↳35 TRUE

  ↳36 QDP

    ↳37 QDPOrderProof (⇔)

    ↳38 QDP

    ↳39 QDPOrderProof (⇔)

    ↳40 QDP

    ↳41 PisEmptyProof (⇔)

    ↳42 TRUE

  ↳43 QDP

    ↳44 QDPOrderProof (⇔)

    ↳45 QDP

    ↳46 QDPOrderProof (⇔)

    ↳47 QDP

    ↳48 QDPOrderProof (⇔)

    ↳49 QDP

    ↳50 QDPOrderProof (⇔)

    ↳51 QDP

    ↳52 QDPOrderProof (⇔)

    ↳53 QDP

    ↳54 PisEmptyProof (⇔)

    ↳55 TRUE

  ↳56 QDP

    ↳57 QDPOrderProof (⇔)

    ↳58 QDP

    ↳59 PisEmptyProof (⇔)

    ↳60 TRUE

  ↳61 QDP

(0) Obligation:

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

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

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

(2) Obligation:

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

ACTIVE(nats) → ADX(zeros)
ACTIVE(zeros) → CONS(0, zeros)
ACTIVE(incr(cons(X, Y))) → CONS(s(X), incr(Y))
ACTIVE(incr(cons(X, Y))) → S(X)
ACTIVE(incr(cons(X, Y))) → INCR(Y)
ACTIVE(adx(cons(X, Y))) → INCR(cons(X, adx(Y)))
ACTIVE(adx(cons(X, Y))) → CONS(X, adx(Y))
ACTIVE(adx(cons(X, Y))) → ADX(Y)
ACTIVE(adx(X)) → ADX(active(X))
ACTIVE(adx(X)) → ACTIVE(X)
ACTIVE(incr(X)) → INCR(active(X))
ACTIVE(incr(X)) → ACTIVE(X)
ACTIVE(hd(X)) → HD(active(X))
ACTIVE(hd(X)) → ACTIVE(X)
ACTIVE(tl(X)) → TL(active(X))
ACTIVE(tl(X)) → ACTIVE(X)
ADX(mark(X)) → ADX(X)
INCR(mark(X)) → INCR(X)
HD(mark(X)) → HD(X)
TL(mark(X)) → TL(X)
PROPER(adx(X)) → ADX(proper(X))
PROPER(adx(X)) → PROPER(X)
PROPER(cons(X1, X2)) → CONS(proper(X1), proper(X2))
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(incr(X)) → INCR(proper(X))
PROPER(incr(X)) → PROPER(X)
PROPER(s(X)) → S(proper(X))
PROPER(s(X)) → PROPER(X)
PROPER(hd(X)) → HD(proper(X))
PROPER(hd(X)) → PROPER(X)
PROPER(tl(X)) → TL(proper(X))
PROPER(tl(X)) → PROPER(X)
ADX(ok(X)) → ADX(X)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
INCR(ok(X)) → INCR(X)
S(ok(X)) → S(X)
HD(ok(X)) → HD(X)
TL(ok(X)) → TL(X)
TOP(mark(X)) → TOP(proper(X))
TOP(mark(X)) → PROPER(X)
TOP(ok(X)) → TOP(active(X))
TOP(ok(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(3) DependencyGraphProof (EQUIVALENT transformation)

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

(4) Complex Obligation (AND)

(5) Obligation:

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

S(ok(X)) → S(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(6) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

S(ok(X)) → S(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
S(x1) = S(x1)
ok(x1) = ok(x1)
active(x1) = active
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

S₁ > [active, mark]
zeros > cons₂ > [ok₁, nats] > [active, mark]
0 > [ok₁, nats] > [active, mark]
top > proper₁ > cons₂ > [ok₁, nats] > [active, mark]

Status:

S₁: [1]
ok₁: [1]
active: []
nats: []
mark: []
zeros: []
cons₂: [1,2]
0: []
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(7) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(8) PisEmptyProof (EQUIVALENT transformation)

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

(9) TRUE

(10) Obligation:

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

CONS(ok(X1), ok(X2)) → CONS(X1, X2)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(11) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

CONS(ok(X1), ok(X2)) → CONS(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
CONS(x1, x2) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1)
0 = 0
incr(x1) = x1
s(x1) = s(x1)
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[active₁, mark] > [s₁, proper₁] > nats
[active₁, mark] > [s₁, proper₁] > zeros > 0 > [ok₁, cons₁]
[active₁, mark] > top

Status:

ok₁: [1]
active₁: [1]
nats: []
mark: []
zeros: []
cons₁: [1]
0: []
s₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(12) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(13) PisEmptyProof (EQUIVALENT transformation)

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

(14) TRUE

(15) Obligation:

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

TL(ok(X)) → TL(X)
TL(mark(X)) → TL(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(16) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TL(mark(X)) → TL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TL(x1) = TL(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = active(x1)
nats = nats
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = s
hd(x1) = hd(x1)
tl(x1) = tl(x1)
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[active₁, 0, proper₁] > zeros > cons₂ > [TL₁, mark₁, nats]
[active₁, 0, proper₁] > zeros > cons₂ > s
[active₁, 0, proper₁] > hd₁ > [TL₁, mark₁, nats]
[active₁, 0, proper₁] > tl₁ > [TL₁, mark₁, nats]

Status:

TL₁: [1]
mark₁: [1]
active₁: [1]
nats: []
zeros: []
cons₂: [2,1]
0: []
s: []
hd₁: [1]
tl₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(17) Obligation:

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

TL(ok(X)) → TL(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(18) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TL(ok(X)) → TL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TL(x1) = TL(x1)
ok(x1) = ok(x1)
active(x1) = active
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

TL₁ > [active, mark]
zeros > cons₂ > [ok₁, nats] > [active, mark]
0 > [ok₁, nats] > [active, mark]
top > proper₁ > cons₂ > [ok₁, nats] > [active, mark]

Status:

TL₁: [1]
ok₁: [1]
active: []
nats: []
mark: []
zeros: []
cons₂: [1,2]
0: []
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(19) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(20) PisEmptyProof (EQUIVALENT transformation)

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

(21) TRUE

(22) Obligation:

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

HD(ok(X)) → HD(X)
HD(mark(X)) → HD(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(23) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

HD(mark(X)) → HD(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
HD(x1) = HD(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = active(x1)
nats = nats
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = s
hd(x1) = hd(x1)
tl(x1) = tl(x1)
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[active₁, 0, proper₁] > zeros > cons₂ > [HD₁, mark₁, nats]
[active₁, 0, proper₁] > zeros > cons₂ > s
[active₁, 0, proper₁] > hd₁ > [HD₁, mark₁, nats]
[active₁, 0, proper₁] > tl₁ > [HD₁, mark₁, nats]

Status:

HD₁: [1]
mark₁: [1]
active₁: [1]
nats: []
zeros: []
cons₂: [2,1]
0: []
s: []
hd₁: [1]
tl₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(24) Obligation:

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

HD(ok(X)) → HD(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(25) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

HD(ok(X)) → HD(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
HD(x1) = HD(x1)
ok(x1) = ok(x1)
active(x1) = active
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

HD₁ > [active, mark]
zeros > cons₂ > [ok₁, nats] > [active, mark]
0 > [ok₁, nats] > [active, mark]
top > proper₁ > cons₂ > [ok₁, nats] > [active, mark]

Status:

HD₁: [1]
ok₁: [1]
active: []
nats: []
mark: []
zeros: []
cons₂: [1,2]
0: []
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(26) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(27) PisEmptyProof (EQUIVALENT transformation)

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

(28) TRUE

(29) Obligation:

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

INCR(ok(X)) → INCR(X)
INCR(mark(X)) → INCR(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(30) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
INCR(x1) = INCR(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = active(x1)
nats = nats
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = s
hd(x1) = hd(x1)
tl(x1) = tl(x1)
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[active₁, 0, proper₁] > zeros > cons₂ > [INCR₁, mark₁, nats]
[active₁, 0, proper₁] > zeros > cons₂ > s
[active₁, 0, proper₁] > hd₁ > [INCR₁, mark₁, nats]
[active₁, 0, proper₁] > tl₁ > [INCR₁, mark₁, nats]

Status:

INCR₁: [1]
mark₁: [1]
active₁: [1]
nats: []
zeros: []
cons₂: [2,1]
0: []
s: []
hd₁: [1]
tl₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(31) Obligation:

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

INCR(ok(X)) → INCR(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(32) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

INCR(ok(X)) → INCR(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
INCR(x1) = INCR(x1)
ok(x1) = ok(x1)
active(x1) = active
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

INCR₁ > [active, mark]
zeros > cons₂ > [ok₁, nats] > [active, mark]
0 > [ok₁, nats] > [active, mark]
top > proper₁ > cons₂ > [ok₁, nats] > [active, mark]

Status:

INCR₁: [1]
ok₁: [1]
active: []
nats: []
mark: []
zeros: []
cons₂: [1,2]
0: []
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(33) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(34) PisEmptyProof (EQUIVALENT transformation)

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

(35) TRUE

(36) Obligation:

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

ADX(ok(X)) → ADX(X)
ADX(mark(X)) → ADX(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(37) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ADX(mark(X)) → ADX(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ADX(x1) = ADX(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = active(x1)
nats = nats
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = s
hd(x1) = hd(x1)
tl(x1) = tl(x1)
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[active₁, 0, proper₁] > zeros > cons₂ > [ADX₁, mark₁, nats]
[active₁, 0, proper₁] > zeros > cons₂ > s
[active₁, 0, proper₁] > hd₁ > [ADX₁, mark₁, nats]
[active₁, 0, proper₁] > tl₁ > [ADX₁, mark₁, nats]

Status:

ADX₁: [1]
mark₁: [1]
active₁: [1]
nats: []
zeros: []
cons₂: [2,1]
0: []
s: []
hd₁: [1]
tl₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(38) Obligation:

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

ADX(ok(X)) → ADX(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(39) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ADX(ok(X)) → ADX(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ADX(x1) = ADX(x1)
ok(x1) = ok(x1)
active(x1) = active
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

ADX₁ > [active, mark]
zeros > cons₂ > [ok₁, nats] > [active, mark]
0 > [ok₁, nats] > [active, mark]
top > proper₁ > cons₂ > [ok₁, nats] > [active, mark]

Status:

ADX₁: [1]
ok₁: [1]
active: []
nats: []
mark: []
zeros: []
cons₂: [1,2]
0: []
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(40) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(41) PisEmptyProof (EQUIVALENT transformation)

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

(42) TRUE

(43) Obligation:

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

PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(adx(X)) → PROPER(X)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(incr(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(hd(X)) → PROPER(X)
PROPER(tl(X)) → PROPER(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(44) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = PROPER(x1)
cons(x1, x2) = cons(x1, x2)
adx(x1) = x1
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
active(x1) = active
nats = nats
mark(x1) = mark
zeros = zeros
0 = 0
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[nats, proper₁] > [zeros, ok, top] > active > cons₂
[nats, proper₁] > [zeros, ok, top] > active > mark
[nats, proper₁] > [zeros, ok, top] > active > 0

Status:

PROPER₁: [1]
cons₂: [1,2]
active: []
nats: []
mark: []
zeros: []
0: []
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(45) Obligation:

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

PROPER(adx(X)) → PROPER(X)
PROPER(incr(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(hd(X)) → PROPER(X)
PROPER(tl(X)) → PROPER(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(46) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(tl(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = PROPER(x1)
adx(x1) = x1
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = tl(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

active₁ > [PROPER₁, tl₁]
active₁ > zeros
active₁ > cons₂
active₁ > 0
[proper₁, ok, top] > [PROPER₁, tl₁]
[proper₁, ok, top] > nats
[proper₁, ok, top] > zeros
[proper₁, ok, top] > cons₂
[proper₁, ok, top] > 0

Status:

PROPER₁: [1]
tl₁: [1]
active₁: [1]
nats: []
zeros: []
cons₂: [1,2]
0: []
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(47) Obligation:

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

PROPER(adx(X)) → PROPER(X)
PROPER(incr(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(hd(X)) → PROPER(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(48) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(s(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = PROPER(x1)
adx(x1) = x1
incr(x1) = x1
s(x1) = s(x1)
hd(x1) = x1
active(x1) = active
nats = nats
mark(x1) = mark
zeros = zeros
cons(x1, x2) = cons
0 = 0
tl(x1) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[nats, proper₁] > [active, cons] > s₁ > ok > top
[nats, proper₁] > [active, cons] > mark > top
[nats, proper₁] > [active, cons] > zeros > 0
[nats, proper₁] > [active, cons] > zeros > ok > top

Status:

PROPER₁: [1]
s₁: [1]
active: []
nats: []
mark: []
zeros: []
cons: []
0: []
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(49) Obligation:

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

PROPER(adx(X)) → PROPER(X)
PROPER(incr(X)) → PROPER(X)
PROPER(hd(X)) → PROPER(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(50) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(incr(X)) → PROPER(X)
PROPER(hd(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = PROPER(x1)
adx(x1) = x1
incr(x1) = incr(x1)
hd(x1) = hd(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark(x1)
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
s(x1) = s
tl(x1) = x1
proper(x1) = x1
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

[active₁, 0] > zeros > [PROPER₁, incr₁, hd₁, mark₁] > cons₂ > [nats, s, ok, top]

Status:

PROPER₁: [1]
incr₁: [1]
hd₁: [1]
active₁: [1]
nats: []
mark₁: [1]
zeros: []
cons₂: [2,1]
0: []
s: []
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(51) Obligation:

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

PROPER(adx(X)) → PROPER(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(52) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(adx(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = x1
adx(x1) = adx(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark(x1)
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = incr(x1)
s(x1) = s(x1)
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

active₁ > [adx₁, proper₁] > [zeros, 0] > cons₂ > [s₁, ok, top] > incr₁ > mark₁
nats > [adx₁, proper₁] > [zeros, 0] > cons₂ > [s₁, ok, top] > incr₁ > mark₁

Status:

adx₁: [1]
active₁: [1]
nats: []
mark₁: [1]
zeros: []
cons₂: [2,1]
0: []
incr₁: [1]
s₁: [1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(53) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(54) PisEmptyProof (EQUIVALENT transformation)

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

(55) TRUE

(56) Obligation:

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

ACTIVE(incr(X)) → ACTIVE(X)
ACTIVE(adx(X)) → ACTIVE(X)
ACTIVE(hd(X)) → ACTIVE(X)
ACTIVE(tl(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(57) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(incr(X)) → ACTIVE(X)
ACTIVE(adx(X)) → ACTIVE(X)
ACTIVE(hd(X)) → ACTIVE(X)
ACTIVE(tl(X)) → ACTIVE(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = x1
incr(x1) = incr(x1)
adx(x1) = adx(x1)
hd(x1) = hd(x1)
tl(x1) = tl(x1)
active(x1) = x1
nats = nats
mark(x1) = mark
zeros = zeros
cons(x1, x2) = cons
0 = 0
s(x1) = s
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Quasi-Precedence:

cons > proper₁ > incr₁ > [zeros, ok] > [hd₁, nats, mark] > adx₁
cons > proper₁ > tl₁ > [zeros, ok] > [hd₁, nats, mark] > adx₁
0 > [zeros, ok] > [hd₁, nats, mark] > adx₁
s > proper₁ > incr₁ > [zeros, ok] > [hd₁, nats, mark] > adx₁
s > proper₁ > tl₁ > [zeros, ok] > [hd₁, nats, mark] > adx₁
top > proper₁ > incr₁ > [zeros, ok] > [hd₁, nats, mark] > adx₁
top > proper₁ > tl₁ > [zeros, ok] > [hd₁, nats, mark] > adx₁

Status:

incr₁: [1]
adx₁: [1]
hd₁: [1]
tl₁: [1]
nats: []
mark: []
zeros: []
cons: []
0: []
s: []
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(58) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(59) PisEmptyProof (EQUIVALENT transformation)

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

(60) TRUE

(61) Obligation:

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

TOP(ok(X)) → TOP(active(X))
TOP(mark(X)) → TOP(proper(X))

The TRS R consists of the following rules:

active(nats) → mark(adx(zeros))
active(zeros) → mark(cons(0, zeros))
active(incr(cons(X, Y))) → mark(cons(s(X), incr(Y)))
active(adx(cons(X, Y))) → mark(incr(cons(X, adx(Y))))
active(hd(cons(X, Y))) → mark(X)
active(tl(cons(X, Y))) → mark(Y)
active(adx(X)) → adx(active(X))
active(incr(X)) → incr(active(X))
active(hd(X)) → hd(active(X))
active(tl(X)) → tl(active(X))
adx(mark(X)) → mark(adx(X))
incr(mark(X)) → mark(incr(X))
hd(mark(X)) → mark(hd(X))
tl(mark(X)) → mark(tl(X))
proper(nats) → ok(nats)
proper(adx(X)) → adx(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(incr(X)) → incr(proper(X))
proper(s(X)) → s(proper(X))
proper(hd(X)) → hd(proper(X))
proper(tl(X)) → tl(proper(X))
adx(ok(X)) → ok(adx(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
incr(ok(X)) → ok(incr(X))
s(ok(X)) → ok(s(X))
hd(ok(X)) → ok(hd(X))
tl(ok(X)) → ok(tl(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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