Termination w.r.t. Q proof of /tmp/tmpB_p4ST/Ex2_Luc03b

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

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 QDPOrderProof (⇔)

    ↳14 QDP

    ↳15 PisEmptyProof (⇔)

    ↳16 TRUE

  ↳17 QDP

    ↳18 QDPOrderProof (⇔)

    ↳19 QDP

    ↳20 QDPOrderProof (⇔)

    ↳21 QDP

    ↳22 PisEmptyProof (⇔)

    ↳23 TRUE

  ↳24 QDP

    ↳25 QDPOrderProof (⇔)

    ↳26 QDP

    ↳27 QDPOrderProof (⇔)

    ↳28 QDP

    ↳29 PisEmptyProof (⇔)

    ↳30 TRUE

  ↳31 QDP

    ↳32 QDPOrderProof (⇔)

    ↳33 QDP

    ↳34 QDPOrderProof (⇔)

    ↳35 QDP

    ↳36 QDPOrderProof (⇔)

    ↳37 QDP

    ↳38 PisEmptyProof (⇔)

    ↳39 TRUE

  ↳40 QDP

    ↳41 QDPOrderProof (⇔)

    ↳42 QDP

    ↳43 QDPOrderProof (⇔)

    ↳44 QDP

    ↳45 PisEmptyProof (⇔)

    ↳46 TRUE

  ↳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 QDPOrderProof (⇔)

    ↳66 QDP

    ↳67 PisEmptyProof (⇔)

    ↳68 TRUE

  ↳69 QDP

    ↳70 QDPOrderProof (⇔)

    ↳71 QDP

    ↳72 QDPOrderProof (⇔)

    ↳73 QDP

    ↳74 PisEmptyProof (⇔)

    ↳75 TRUE

(0) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(fst(s(X), cons(Y, Z))) → CONS(Y, fst(X, Z))
ACTIVE(fst(s(X), cons(Y, Z))) → FST(X, Z)
ACTIVE(from(X)) → CONS(X, from(s(X)))
ACTIVE(from(X)) → FROM(s(X))
ACTIVE(from(X)) → S(X)
ACTIVE(add(s(X), Y)) → S(add(X, Y))
ACTIVE(add(s(X), Y)) → ADD(X, Y)
ACTIVE(len(cons(X, Z))) → S(len(Z))
ACTIVE(len(cons(X, Z))) → LEN(Z)
ACTIVE(cons(X1, X2)) → CONS(active(X1), X2)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X1, X2)) → FST(active(X1), X2)
ACTIVE(fst(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X1, X2)) → FST(X1, active(X2))
ACTIVE(fst(X1, X2)) → ACTIVE(X2)
ACTIVE(from(X)) → FROM(active(X))
ACTIVE(from(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ADD(active(X1), X2)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
ACTIVE(add(X1, X2)) → ADD(X1, active(X2))
ACTIVE(add(X1, X2)) → ACTIVE(X2)
ACTIVE(len(X)) → LEN(active(X))
ACTIVE(len(X)) → ACTIVE(X)
CONS(mark(X1), X2) → CONS(X1, X2)
FST(mark(X1), X2) → FST(X1, X2)
FST(X1, mark(X2)) → FST(X1, X2)
FROM(mark(X)) → FROM(X)
ADD(mark(X1), X2) → ADD(X1, X2)
ADD(X1, mark(X2)) → ADD(X1, X2)
LEN(mark(X)) → LEN(X)
PROPER(s(X)) → S(proper(X))
PROPER(s(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(fst(X1, X2)) → FST(proper(X1), proper(X2))
PROPER(fst(X1, X2)) → PROPER(X1)
PROPER(fst(X1, X2)) → PROPER(X2)
PROPER(from(X)) → FROM(proper(X))
PROPER(from(X)) → PROPER(X)
PROPER(add(X1, X2)) → ADD(proper(X1), proper(X2))
PROPER(add(X1, X2)) → PROPER(X1)
PROPER(add(X1, X2)) → PROPER(X2)
PROPER(len(X)) → LEN(proper(X))
PROPER(len(X)) → PROPER(X)
S(ok(X)) → S(X)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
FST(ok(X1), ok(X2)) → FST(X1, X2)
FROM(ok(X)) → FROM(X)
ADD(ok(X1), ok(X2)) → ADD(X1, X2)
LEN(ok(X)) → LEN(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(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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 24 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(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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)
fst(x1, x2) = fst(x1, x2)
0 = 0
mark(x1) = mark
nil = nil
s(x1) = s(x1)
cons(x1, x2) = cons(x2)
from(x1) = x1
add(x1, x2) = add(x2)
len(x1) = len(x1)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Precedence:

active₁ > 0 > nil > ok₁
active₁ > s₁ > cons₁ > mark > fst₂ > nil > ok₁
active₁ > s₁ > cons₁ > len₁ > ok₁
active₁ > add₁ > mark > fst₂ > nil > ok₁
proper₁ > 0 > nil > ok₁
proper₁ > s₁ > cons₁ > mark > fst₂ > nil > ok₁
proper₁ > s₁ > cons₁ > len₁ > ok₁
proper₁ > add₁ > mark > fst₂ > nil > ok₁
top > ok₁

Status:

ok₁: multiset
active₁: [1]
fst₂: multiset
0: multiset
mark: []
nil: multiset
s₁: [1]
cons₁: [1]
add₁: [1]
len₁: [1]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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:

LEN(ok(X)) → LEN(X)
LEN(mark(X)) → LEN(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

LEN(ok(X)) → LEN(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
LEN(x1) = x1
ok(x1) = ok(x1)
mark(x1) = x1
active(x1) = active(x1)
fst(x1, x2) = x2
0 = 0
nil = nil
s(x1) = x1
cons(x1, x2) = x2
from(x1) = x1
add(x1, x2) = x2
len(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Precedence:

top > active₁ > 0 > nil > ok₁
top > proper > 0 > nil > ok₁

Status:

ok₁: [1]
active₁: [1]
0: multiset
nil: multiset
proper: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(12) Obligation:

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

LEN(mark(X)) → LEN(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

LEN(mark(X)) → LEN(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
LEN(x1) = LEN(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s
cons(x1, x2) = x1
from(x1) = x1
add(x1, x2) = add(x1, x2)
len(x1) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Precedence:

LEN₁ > mark₁
active₁ > nil > 0 > mark₁
active₁ > nil > ok > fst₂ > mark₁
active₁ > nil > ok > add₂ > mark₁
active₁ > nil > ok > top > mark₁
active₁ > s > proper₁ > 0 > mark₁
active₁ > s > proper₁ > ok > fst₂ > mark₁
active₁ > s > proper₁ > ok > add₂ > mark₁
active₁ > s > proper₁ > ok > top > mark₁

Status:

LEN₁: [1]
mark₁: [1]
active₁: multiset
fst₂: [1,2]
0: multiset
nil: multiset
s: multiset
add₂: [1,2]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(14) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(15) PisEmptyProof (EQUIVALENT transformation)

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

(16) TRUE

(17) Obligation:

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

ADD(X1, mark(X2)) → ADD(X1, X2)
ADD(mark(X1), X2) → ADD(X1, X2)
ADD(ok(X1), ok(X2)) → ADD(X1, X2)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

ADD(ok(X1), ok(X2)) → ADD(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ADD(x1, x2) = ADD(x1)
mark(x1) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = x1
cons(x1, x2) = cons(x2)
from(x1) = from(x1)
add(x1, x2) = x2
len(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Precedence:

active₁ > fst₂ > cons₁ > ok₁ > ADD₁
active₁ > nil > 0 > ok₁ > ADD₁
active₁ > from₁ > cons₁ > ok₁ > ADD₁
top > proper₁ > fst₂ > cons₁ > ok₁ > ADD₁
top > proper₁ > from₁ > cons₁ > ok₁ > ADD₁

Status:

ADD₁: multiset
ok₁: multiset
active₁: [1]
fst₂: [1,2]
0: multiset
nil: multiset
cons₁: [1]
from₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(19) Obligation:

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

ADD(X1, mark(X2)) → ADD(X1, X2)
ADD(mark(X1), X2) → ADD(X1, X2)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ADD(X1, mark(X2)) → ADD(X1, X2)
ADD(mark(X1), X2) → ADD(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ADD(x1, x2) = ADD(x1, x2)
mark(x1) = mark(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s(x1)
cons(x1, x2) = cons(x1, x2)
from(x1) = from(x1)
add(x1, x2) = add(x1, x2)
len(x1) = len(x1)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Precedence:

ADD₂ > mark₁
active₁ > fst₂ > ok > s₁ > mark₁
active₁ > fst₂ > ok > cons₂ > mark₁
active₁ > fst₂ > ok > from₁ > mark₁
active₁ > fst₂ > ok > add₂ > mark₁
active₁ > fst₂ > ok > len₁ > mark₁
active₁ > fst₂ > ok > top > mark₁
active₁ > nil > 0 > mark₁
active₁ > nil > ok > s₁ > mark₁
active₁ > nil > ok > cons₂ > mark₁
active₁ > nil > ok > from₁ > mark₁
active₁ > nil > ok > add₂ > mark₁
active₁ > nil > ok > len₁ > mark₁
active₁ > nil > ok > top > mark₁
proper₁ > fst₂ > ok > s₁ > mark₁
proper₁ > fst₂ > ok > cons₂ > mark₁
proper₁ > fst₂ > ok > from₁ > mark₁
proper₁ > fst₂ > ok > add₂ > mark₁
proper₁ > fst₂ > ok > len₁ > mark₁
proper₁ > fst₂ > ok > top > mark₁
proper₁ > nil > 0 > mark₁
proper₁ > nil > ok > s₁ > mark₁
proper₁ > nil > ok > cons₂ > mark₁
proper₁ > nil > ok > from₁ > mark₁
proper₁ > nil > ok > add₂ > mark₁
proper₁ > nil > ok > len₁ > mark₁
proper₁ > nil > ok > top > mark₁

Status:

ADD₂: multiset
mark₁: multiset
active₁: [1]
fst₂: [1,2]
0: multiset
nil: multiset
s₁: [1]
cons₂: [2,1]
from₁: [1]
add₂: [2,1]
len₁: [1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(21) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(22) PisEmptyProof (EQUIVALENT transformation)

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

(23) TRUE

(24) Obligation:

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

FROM(ok(X)) → FROM(X)
FROM(mark(X)) → FROM(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

FROM(ok(X)) → FROM(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FROM(x1) = x1
ok(x1) = ok(x1)
mark(x1) = x1
active(x1) = active(x1)
fst(x1, x2) = x2
0 = 0
nil = nil
s(x1) = x1
cons(x1, x2) = x2
from(x1) = x1
add(x1, x2) = x2
len(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Precedence:

top > active₁ > 0 > nil > ok₁
top > proper > 0 > nil > ok₁

Status:

ok₁: [1]
active₁: [1]
0: multiset
nil: multiset
proper: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(26) Obligation:

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

FROM(mark(X)) → FROM(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

FROM(mark(X)) → FROM(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FROM(x1) = FROM(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s
cons(x1, x2) = x1
from(x1) = x1
add(x1, x2) = add(x1, x2)
len(x1) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Precedence:

FROM₁ > mark₁
active₁ > nil > 0 > mark₁
active₁ > nil > ok > fst₂ > mark₁
active₁ > nil > ok > add₂ > mark₁
active₁ > nil > ok > top > mark₁
active₁ > s > proper₁ > 0 > mark₁
active₁ > s > proper₁ > ok > fst₂ > mark₁
active₁ > s > proper₁ > ok > add₂ > mark₁
active₁ > s > proper₁ > ok > top > mark₁

Status:

FROM₁: [1]
mark₁: [1]
active₁: multiset
fst₂: [1,2]
0: multiset
nil: multiset
s: multiset
add₂: [1,2]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(28) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(29) PisEmptyProof (EQUIVALENT transformation)

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

(30) TRUE

(31) Obligation:

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

FST(X1, mark(X2)) → FST(X1, X2)
FST(mark(X1), X2) → FST(X1, X2)
FST(ok(X1), ok(X2)) → FST(X1, X2)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

FST(mark(X1), X2) → FST(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FST(x1, x2) = FST(x1)
mark(x1) = mark(x1)
ok(x1) = x1
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s(x1)
cons(x1, x2) = cons(x1, x2)
from(x1) = x1
add(x1, x2) = add(x1, x2)
len(x1) = x1
proper(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

FST₁ > nil
active₁ > 0 > nil
active₁ > s₁ > cons₂ > fst₂ > mark₁ > nil
active₁ > add₂ > mark₁ > nil
top > nil

Status:

FST₁: [1]
mark₁: [1]
active₁: [1]
fst₂: multiset
0: multiset
nil: multiset
s₁: [1]
cons₂: [2,1]
add₂: [1,2]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(33) Obligation:

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

FST(X1, mark(X2)) → FST(X1, X2)
FST(ok(X1), ok(X2)) → FST(X1, X2)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

FST(X1, mark(X2)) → FST(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FST(x1, x2) = FST(x1, x2)
mark(x1) = mark(x1)
ok(x1) = x1
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s(x1)
cons(x1, x2) = cons(x1, x2)
from(x1) = from(x1)
add(x1, x2) = add(x1, x2)
len(x1) = len(x1)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Precedence:

active₁ > fst₂ > nil > mark₁ > top > FST₂
active₁ > fst₂ > nil > 0 > FST₂
active₁ > fst₂ > cons₂ > s₁ > mark₁ > top > FST₂
active₁ > fst₂ > cons₂ > len₁ > mark₁ > top > FST₂
active₁ > fst₂ > cons₂ > len₁ > 0 > FST₂
active₁ > from₁ > cons₂ > s₁ > mark₁ > top > FST₂
active₁ > from₁ > cons₂ > len₁ > mark₁ > top > FST₂
active₁ > from₁ > cons₂ > len₁ > 0 > FST₂
active₁ > add₂ > s₁ > mark₁ > top > FST₂
proper₁ > fst₂ > nil > mark₁ > top > FST₂
proper₁ > fst₂ > nil > 0 > FST₂
proper₁ > fst₂ > cons₂ > s₁ > mark₁ > top > FST₂
proper₁ > fst₂ > cons₂ > len₁ > mark₁ > top > FST₂
proper₁ > fst₂ > cons₂ > len₁ > 0 > FST₂
proper₁ > from₁ > cons₂ > s₁ > mark₁ > top > FST₂
proper₁ > from₁ > cons₂ > len₁ > mark₁ > top > FST₂
proper₁ > from₁ > cons₂ > len₁ > 0 > FST₂
proper₁ > add₂ > s₁ > mark₁ > top > FST₂

Status:

FST₂: multiset
mark₁: multiset
active₁: [1]
fst₂: [2,1]
0: multiset
nil: multiset
s₁: [1]
cons₂: multiset
from₁: [1]
add₂: [2,1]
len₁: [1]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(35) Obligation:

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

FST(ok(X1), ok(X2)) → FST(X1, X2)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(36) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

FST(ok(X1), ok(X2)) → FST(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FST(x1, x2) = FST(x2)
ok(x1) = ok(x1)
active(x1) = x1
fst(x1, x2) = x2
0 = 0
mark(x1) = mark
nil = nil
s(x1) = x1
cons(x1, x2) = x2
from(x1) = x1
add(x1, x2) = x2
len(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Precedence:

FST₁ > mark
proper > 0 > ok₁ > top > mark
proper > 0 > nil > mark

Status:

FST₁: [1]
ok₁: [1]
0: multiset
mark: multiset
nil: multiset
proper: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(37) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(38) PisEmptyProof (EQUIVALENT transformation)

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

(39) TRUE

(40) Obligation:

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

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

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

CONS(mark(X1), 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(x1, x2)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s(x1)
cons(x1, x2) = cons(x1, x2)
from(x1) = from(x1)
add(x1, x2) = add(x1, x2)
len(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Precedence:

CONS₂ > mark₁
active₁ > 0 > mark₁
active₁ > nil > mark₁
active₁ > s₁ > fst₂ > mark₁
active₁ > s₁ > cons₂ > mark₁
active₁ > s₁ > add₂ > mark₁
active₁ > from₁ > cons₂ > mark₁
proper₁ > 0 > mark₁
proper₁ > nil > mark₁
proper₁ > s₁ > fst₂ > mark₁
proper₁ > s₁ > cons₂ > mark₁
proper₁ > s₁ > add₂ > mark₁
proper₁ > from₁ > cons₂ > mark₁
top > mark₁

Status:

CONS₂: [1,2]
mark₁: multiset
active₁: [1]
fst₂: [1,2]
0: multiset
nil: multiset
s₁: [1]
cons₂: [2,1]
from₁: [1]
add₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(42) 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(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(43) 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) = x1
fst(x1, x2) = x2
0 = 0
mark(x1) = mark
nil = nil
s(x1) = x1
cons(x1, x2) = x2
from(x1) = x1
add(x1, x2) = x2
len(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Precedence:

CONS₁ > mark
proper > 0 > ok₁ > top > mark
proper > 0 > nil > mark

Status:

CONS₁: [1]
ok₁: [1]
0: multiset
mark: multiset
nil: multiset
proper: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(44) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(45) PisEmptyProof (EQUIVALENT transformation)

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

(46) TRUE

(47) Obligation:

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

PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(s(X)) → PROPER(X)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(fst(X1, X2)) → PROPER(X1)
PROPER(fst(X1, X2)) → PROPER(X2)
PROPER(from(X)) → PROPER(X)
PROPER(add(X1, X2)) → PROPER(X1)
PROPER(add(X1, X2)) → PROPER(X2)
PROPER(len(X)) → PROPER(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(fst(X1, X2)) → PROPER(X1)
PROPER(fst(X1, X2)) → PROPER(X2)
PROPER(add(X1, X2)) → PROPER(X1)
PROPER(add(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)
s(x1) = x1
fst(x1, x2) = fst(x1, x2)
from(x1) = x1
add(x1, x2) = add(x1, x2)
len(x1) = x1
active(x1) = active(x1)
0 = 0
mark(x1) = x1
nil = nil
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

PROPER₁ > top
active₁ > fst₂ > cons₂ > top
active₁ > add₂ > top
active₁ > nil > 0 > top
proper₁ > fst₂ > cons₂ > top
proper₁ > add₂ > top
proper₁ > nil > 0 > top

Status:

PROPER₁: multiset
cons₂: multiset
fst₂: multiset
add₂: [2,1]
active₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(s(X)) → PROPER(X)
PROPER(from(X)) → PROPER(X)
PROPER(len(X)) → PROPER(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(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)
s(x1) = s(x1)
from(x1) = x1
len(x1) = x1
active(x1) = active(x1)
fst(x1, x2) = fst(x2)
0 = 0
mark(x1) = mark
nil = nil
cons(x1, x2) = cons(x1, x2)
add(x1, x2) = add(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

active₁ > fst₁ > mark > cons₂ > nil
active₁ > add₂ > s₁ > PROPER₁ > nil
active₁ > add₂ > s₁ > cons₂ > nil
active₁ > add₂ > mark > cons₂ > nil
proper₁ > fst₁ > mark > cons₂ > nil
proper₁ > 0 > mark > cons₂ > nil
proper₁ > add₂ > s₁ > PROPER₁ > nil
proper₁ > add₂ > s₁ > cons₂ > nil
proper₁ > add₂ > mark > cons₂ > nil
top > nil

Status:

PROPER₁: multiset
s₁: [1]
active₁: [1]
fst₁: [1]
0: multiset
mark: []
nil: multiset
cons₂: [2,1]
add₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(from(X)) → PROPER(X)
PROPER(len(X)) → PROPER(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(len(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)
from(x1) = x1
len(x1) = len(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
mark(x1) = mark
nil = nil
s(x1) = s
cons(x1, x2) = cons
add(x1, x2) = x1
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

nil > 0 > mark
s > cons > active₁ > len₁ > PROPER₁ > mark
s > cons > active₁ > len₁ > 0 > mark
s > cons > active₁ > fst₂ > mark
top > mark

Status:

PROPER₁: multiset
len₁: [1]
active₁: [1]
fst₂: [1,2]
0: multiset
mark: multiset
nil: multiset
s: multiset
cons: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(from(X)) → PROPER(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(from(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)
from(x1) = from(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x2)
0 = 0
mark(x1) = x1
nil = nil
s(x1) = s
cons(x1, x2) = x2
add(x1, x2) = x2
len(x1) = len(x1)
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

top > active₁ > from₁
top > active₁ > fst₁
top > active₁ > 0
top > active₁ > nil
top > active₁ > len₁ > s

Status:

PROPER₁: [1]
from₁: [1]
active₁: [1]
fst₁: [1]
0: multiset
nil: multiset
s: multiset
len₁: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(fst(X1, X2)) → ACTIVE(X1)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X1, X2)) → ACTIVE(X2)
ACTIVE(from(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
ACTIVE(add(X1, X2)) → ACTIVE(X2)
ACTIVE(len(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(fst(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X1, X2)) → ACTIVE(X2)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
ACTIVE(add(X1, X2)) → ACTIVE(X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = ACTIVE(x1)
fst(x1, x2) = fst(x1, x2)
cons(x1, x2) = x1
from(x1) = x1
add(x1, x2) = add(x1, x2)
len(x1) = x1
active(x1) = x1
0 = 0
mark(x1) = mark
nil = nil
s(x1) = s(x1)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

ACTIVE₁ > mark
proper₁ > nil > 0 > mark
proper₁ > s₁ > fst₂ > mark
proper₁ > s₁ > add₂ > mark
top > mark

Status:

ACTIVE₁: [1]
fst₂: [1,2]
add₂: [1,2]
0: multiset
mark: multiset
nil: multiset
s₁: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(from(X)) → ACTIVE(X)
ACTIVE(len(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(len(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)
cons(x1, x2) = x1
from(x1) = x1
len(x1) = len(x1)
active(x1) = active(x1)
fst(x1, x2) = fst
0 = 0
mark(x1) = mark
nil = nil
s(x1) = s
add(x1, x2) = add(x1, x2)
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

fst > active₁ > mark > len₁ > ACTIVE₁ > top
fst > active₁ > mark > len₁ > 0 > top
fst > active₁ > mark > add₂ > top
nil > mark > len₁ > ACTIVE₁ > top
nil > mark > len₁ > 0 > top
nil > mark > add₂ > top
s > mark > len₁ > ACTIVE₁ > top
s > mark > len₁ > 0 > top
s > mark > add₂ > top

Status:

ACTIVE₁: multiset
len₁: [1]
active₁: [1]
fst: []
0: multiset
mark: []
nil: multiset
s: []
add₂: [2,1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(from(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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(from(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)
cons(x1, x2) = x1
from(x1) = from(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
mark(x1) = x1
nil = nil
s(x1) = s(x1)
add(x1, x2) = x2
len(x1) = len
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

active₁ > from₁ > ACTIVE₁
active₁ > fst₂ > ACTIVE₁
active₁ > nil > 0 > ACTIVE₁
active₁ > s₁ > ACTIVE₁
active₁ > len > ACTIVE₁
proper₁ > from₁ > ACTIVE₁
proper₁ > fst₂ > ACTIVE₁
proper₁ > nil > 0 > ACTIVE₁
proper₁ > s₁ > ACTIVE₁
proper₁ > len > ACTIVE₁
top > ACTIVE₁

Status:

ACTIVE₁: multiset
from₁: [1]
active₁: [1]
fst₂: multiset
0: multiset
nil: multiset
s₁: [1]
len: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(64) Obligation:

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

ACTIVE(cons(X1, X2)) → ACTIVE(X1)

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(cons(X1, X2)) → ACTIVE(X1)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = ACTIVE(x1)
cons(x1, x2) = cons(x1)
active(x1) = active(x1)
fst(x1, x2) = fst(x1, x2)
0 = 0
mark(x1) = x1
nil = nil
s(x1) = s
from(x1) = x1
add(x1, x2) = add(x1, x2)
len(x1) = len
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

active₁ > nil > 0 > ACTIVE₁
active₁ > s > cons₁ > fst₂ > ACTIVE₁
active₁ > s > cons₁ > len > 0 > ACTIVE₁
active₁ > s > add₂ > ACTIVE₁
proper₁ > nil > 0 > ACTIVE₁
proper₁ > s > cons₁ > fst₂ > ACTIVE₁
proper₁ > s > cons₁ > len > 0 > ACTIVE₁
proper₁ > s > add₂ > ACTIVE₁
top > ACTIVE₁

Status:

ACTIVE₁: multiset
cons₁: multiset
active₁: [1]
fst₂: [1,2]
0: multiset
nil: multiset
s: multiset
add₂: [1,2]
len: []
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(66) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(67) PisEmptyProof (EQUIVALENT transformation)

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

(68) TRUE

(69) 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(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(70) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TOP(mark(X)) → TOP(proper(X))

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TOP(x1) = x1
ok(x1) = x1
active(x1) = x1
mark(x1) = mark(x1)
proper(x1) = x1
fst(x1, x2) = fst(x1, x2)
0 = 0
nil = nil
s(x1) = s
cons(x1, x2) = cons(x1)
from(x1) = from(x1)
add(x1, x2) = add(x1, x2)
len(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Precedence:

from₁ > cons₁ > fst₂ > nil > mark₁ > top
from₁ > cons₁ > fst₂ > nil > 0 > top
from₁ > cons₁ > s > top
add₂ > mark₁ > top
add₂ > s > top

Status:

mark₁: [1]
fst₂: [1,2]
0: multiset
nil: multiset
s: multiset
cons₁: [1]
from₁: [1]
add₂: [2,1]
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(71) Obligation:

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

TOP(ok(X)) → TOP(active(X))

The TRS R consists of the following rules:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(72) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TOP(ok(X)) → TOP(active(X))

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TOP(x1) = TOP(x1)
ok(x1) = ok(x1)
active(x1) = x1
fst(x1, x2) = x1
0 = 0
mark(x1) = mark
nil = nil
s(x1) = x1
cons(x1, x2) = x2
from(x1) = x1
add(x1, x2) = x1
len(x1) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Precedence:

TOP₁ > mark
proper > nil > ok₁ > mark
proper > nil > 0 > mark
top > mark

Status:

TOP₁: multiset
ok₁: [1]
0: multiset
mark: []
nil: multiset
proper: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(73) Obligation:

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

active(fst(0, Z)) → mark(nil)
active(fst(s(X), cons(Y, Z))) → mark(cons(Y, fst(X, Z)))
active(from(X)) → mark(cons(X, from(s(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(len(nil)) → mark(0)
active(len(cons(X, Z))) → mark(s(len(Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(fst(X1, X2)) → fst(active(X1), X2)
active(fst(X1, X2)) → fst(X1, active(X2))
active(from(X)) → from(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(len(X)) → len(active(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
fst(mark(X1), X2) → mark(fst(X1, X2))
fst(X1, mark(X2)) → mark(fst(X1, X2))
from(mark(X)) → mark(from(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
len(mark(X)) → mark(len(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(nil) → ok(nil)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(fst(X1, X2)) → fst(proper(X1), proper(X2))
proper(from(X)) → from(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(len(X)) → len(proper(X))
s(ok(X)) → ok(s(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
fst(ok(X1), ok(X2)) → ok(fst(X1, X2))
from(ok(X)) → ok(from(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
len(ok(X)) → ok(len(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.

(74) PisEmptyProof (EQUIVALENT transformation)

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

(0) Obligation:

(1) DependencyPairsProof (EQUIVALENT transformation)

(2) Obligation:

(3) DependencyGraphProof (EQUIVALENT transformation)

(4) Complex Obligation (AND)

(5) Obligation:

(6) QDPOrderProof (EQUIVALENT transformation)

(7) Obligation:

(8) PisEmptyProof (EQUIVALENT transformation)

(9) TRUE

(10) Obligation:

(11) QDPOrderProof (EQUIVALENT transformation)

(12) Obligation:

(13) QDPOrderProof (EQUIVALENT transformation)

(14) Obligation:

(15) PisEmptyProof (EQUIVALENT transformation)

(16) TRUE

(17) Obligation:

(18) QDPOrderProof (EQUIVALENT transformation)

(19) Obligation:

(20) QDPOrderProof (EQUIVALENT transformation)

(21) Obligation:

(22) PisEmptyProof (EQUIVALENT transformation)

(23) TRUE

(24) Obligation:

(25) QDPOrderProof (EQUIVALENT transformation)

(26) Obligation:

(27) QDPOrderProof (EQUIVALENT transformation)

(28) Obligation:

(29) PisEmptyProof (EQUIVALENT transformation)

(30) TRUE

(31) Obligation:

(32) QDPOrderProof (EQUIVALENT transformation)

(33) Obligation:

(34) QDPOrderProof (EQUIVALENT transformation)

(35) Obligation:

(36) QDPOrderProof (EQUIVALENT transformation)

(37) Obligation:

(38) PisEmptyProof (EQUIVALENT transformation)

(39) TRUE

(40) Obligation:

(41) QDPOrderProof (EQUIVALENT transformation)

(42) Obligation:

(43) QDPOrderProof (EQUIVALENT transformation)

(44) Obligation:

(45) PisEmptyProof (EQUIVALENT transformation)

(46) TRUE

(47) Obligation:

(48) QDPOrderProof (EQUIVALENT transformation)

(49) Obligation:

(50) QDPOrderProof (EQUIVALENT transformation)

(51) Obligation:

(52) QDPOrderProof (EQUIVALENT transformation)

(53) Obligation:

(54) QDPOrderProof (EQUIVALENT transformation)

(55) Obligation:

(56) PisEmptyProof (EQUIVALENT transformation)

(57) TRUE

(58) Obligation:

(59) QDPOrderProof (EQUIVALENT transformation)

(60) Obligation:

(61) QDPOrderProof (EQUIVALENT transformation)

(62) Obligation:

(63) QDPOrderProof (EQUIVALENT transformation)

(64) Obligation:

(65) QDPOrderProof (EQUIVALENT transformation)

(66) Obligation:

(67) PisEmptyProof (EQUIVALENT transformation)

(68) TRUE

(69) Obligation:

(70) QDPOrderProof (EQUIVALENT transformation)

(71) Obligation:

(72) QDPOrderProof (EQUIVALENT transformation)

(73) Obligation:

(74) PisEmptyProof (EQUIVALENT transformation)

(75) TRUE