Termination w.r.t. Q proof of /tmp/tmpRAC05F/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 QDPOrderProof (⇔)

    ↳55 QDP

    ↳56 PisEmptyProof (⇔)

    ↳57 TRUE

  ↳58 QDP

    ↳59 QDPOrderProof (⇔)

    ↳60 QDP

    ↳61 QDPOrderProof (⇔)

    ↳62 QDP

    ↳63 QDPOrderProof (⇔)

    ↳64 QDP

    ↳65 PisEmptyProof (⇔)

    ↳66 TRUE

  ↳67 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) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = x1
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

ok₁: [1]
active₁: multiset
nats: multiset
mark: multiset
zeros: multiset
0: multiset
proper: []
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) = CONS(x2)
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = x1
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

CONS₁: multiset
ok₁: multiset
active₁: [1]
nats: multiset
mark: multiset
zeros: multiset
0: multiset
proper: multiset
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) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

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

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) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = x1
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

ok₁: [1]
active₁: multiset
nats: multiset
mark: multiset
zeros: multiset
0: multiset
proper: []
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) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

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

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) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = x1
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

ok₁: [1]
active₁: multiset
nats: multiset
mark: multiset
zeros: multiset
0: multiset
proper: []
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) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

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

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) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = x1
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

ok₁: [1]
active₁: multiset
nats: multiset
mark: multiset
zeros: multiset
0: multiset
proper: []
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) = x1
tl(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

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

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) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = x1
zeros = zeros
cons(x1, x2) = x1
0 = 0
incr(x1) = x1
s(x1) = x1
hd(x1) = x1
tl(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

ok₁: [1]
active₁: multiset
nats: multiset
mark: multiset
zeros: multiset
0: multiset
proper: []
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(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

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

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(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
tl(x1) = x1
active(x1) = active(x1)
nats = nats
mark(x1) = mark(x1)
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
proper(x1) = proper(x1)
ok(x1) = ok(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

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

Status:

PROPER₁: [1]
s₁: multiset
active₁: [1]
nats: multiset
mark₁: multiset
zeros: multiset
cons₂: [1,2]
0: multiset
proper₁: [1]
ok₁: [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))

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

(48) 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) = x1
adx(x1) = x1
incr(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
s(x1) = x1
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, zeros, cons₂, top] > tl₁
[active₁, zeros, cons₂, top] > 0

Status:

tl₁: [1]
active₁: [1]
nats: multiset
zeros: multiset
cons₂: [1,2]
0: multiset
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)

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) = x1
active(x1) = x1
nats = nats
mark(x1) = mark
zeros = zeros
cons(x1, x2) = x1
0 = 0
s(x1) = s(x1)
tl(x1) = tl
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[incr₁, s₁] > PROPER₁ > [mark, zeros, tl]
nats > [mark, zeros, tl]
0 > [mark, zeros, tl]
top > [mark, zeros, tl]

Status:

PROPER₁: multiset
incr₁: [1]
nats: multiset
mark: multiset
zeros: multiset
0: multiset
s₁: multiset
tl: multiset
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)
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.

(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) = PROPER(x1)
adx(x1) = adx(x1)
hd(x1) = x1
active(x1) = active(x1)
nats = nats
mark(x1) = x1
zeros = zeros
cons(x1, x2) = cons(x1, x2)
0 = 0
incr(x1) = x1
s(x1) = s
tl(x1) = x1
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, top] > [zeros, cons₂, 0, s] > [PROPER₁, adx₁]

Status:

PROPER₁: multiset
adx₁: multiset
active₁: [1]
nats: multiset
zeros: multiset
cons₂: [2,1]
0: multiset
s: multiset
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:
The TRS P consists of the following rules:

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.

(54) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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)
hd(x1) = hd(x1)
active(x1) = active(x1)
nats = nats
mark(x1) = mark
adx(x1) = adx
zeros = zeros
cons(x1, x2) = x2
0 = 0
incr(x1) = x1
s(x1) = s(x1)
tl(x1) = tl(x1)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

top > proper₁ > [hd₁, active₁, adx] > mark > tl₁
top > proper₁ > [hd₁, active₁, adx] > zeros
top > proper₁ > [hd₁, active₁, adx] > s₁
top > proper₁ > nats

Status:

PROPER₁: [1]
hd₁: [1]
active₁: [1]
nats: multiset
mark: multiset
adx: []
zeros: multiset
0: multiset
s₁: [1]
tl₁: multiset
proper₁: multiset
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))

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

(56) PisEmptyProof (EQUIVALENT transformation)

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

(57) TRUE

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

(59) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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) = ACTIVE(x1)
incr(x1) = x1
adx(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
s(x1) = s
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

active₁ > tl₁ > ACTIVE₁
active₁ > cons₂
active₁ > 0
active₁ > s
[nats, zeros] > cons₂
[nats, zeros] > 0

Status:

ACTIVE₁: multiset
tl₁: [1]
active₁: [1]
nats: multiset
zeros: multiset
cons₂: multiset
0: multiset
s: []
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))

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

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.

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

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

Recursive path order with status [RPO].
Quasi-Precedence:

[incr₁, adx₁, active₁, tl₁] > ACTIVE₁
[incr₁, adx₁, active₁, tl₁] > 0 > [nats, zeros, cons₂, ok] > top

Status:

ACTIVE₁: multiset
incr₁: [1]
adx₁: [1]
active₁: [1]
nats: multiset
zeros: multiset
cons₂: multiset
0: multiset
tl₁: [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))

(62) Obligation:

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

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

(63) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(hd(X)) → ACTIVE(X)

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

Recursive path order with status [RPO].
Quasi-Precedence:

top > proper₁ > [hd₁, active₁, adx] > mark > tl₁
top > proper₁ > [hd₁, active₁, adx] > zeros
top > proper₁ > [hd₁, active₁, adx] > s₁
top > proper₁ > nats

Status:

ACTIVE₁: [1]
hd₁: [1]
active₁: [1]
nats: multiset
mark: multiset
adx: []
zeros: multiset
0: multiset
s₁: [1]
tl₁: multiset
proper₁: multiset
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))

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

(65) PisEmptyProof (EQUIVALENT transformation)

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

(66) TRUE

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