Termination w.r.t. Q proof of /tmp/tmppu6Yjz/PALINDROME_nosorts_noand

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

    ↳9 QDP

    ↳10 PisEmptyProof (⇔)

    ↳11 TRUE

  ↳12 QDP

    ↳13 QDPOrderProof (⇔)

    ↳14 QDP

    ↳15 QDPOrderProof (⇔)

    ↳16 QDP

    ↳17 PisEmptyProof (⇔)

    ↳18 TRUE

  ↳19 QDP

    ↳20 QDPOrderProof (⇔)

    ↳21 QDP

    ↳22 QDPOrderProof (⇔)

    ↳23 QDP

    ↳24 PisEmptyProof (⇔)

    ↳25 TRUE

  ↳26 QDP

    ↳27 QDPOrderProof (⇔)

    ↳28 QDP

    ↳29 QDPOrderProof (⇔)

    ↳30 QDP

    ↳31 QDPOrderProof (⇔)

    ↳32 QDP

    ↳33 PisEmptyProof (⇔)

    ↳34 TRUE

  ↳35 QDP

    ↳36 QDPOrderProof (⇔)

    ↳37 QDP

    ↳38 QDPOrderProof (⇔)

    ↳39 QDP

    ↳40 QDPOrderProof (⇔)

    ↳41 QDP

    ↳42 QDPOrderProof (⇔)

    ↳43 QDP

    ↳44 PisEmptyProof (⇔)

    ↳45 TRUE

  ↳46 QDP

    ↳47 QDPOrderProof (⇔)

    ↳48 QDP

    ↳49 QDPOrderProof (⇔)

    ↳50 QDP

    ↳51 QDPOrderProof (⇔)

    ↳52 QDP

    ↳53 QDPOrderProof (⇔)

    ↳54 QDP

    ↳55 PisEmptyProof (⇔)

    ↳56 TRUE

  ↳57 QDP

    ↳58 QDPOrderProof (⇔)

    ↳59 QDP

    ↳60 QDPOrderProof (⇔)

    ↳61 QDP

    ↳62 PisEmptyProof (⇔)

    ↳63 TRUE

(0) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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(__(__(X, Y), Z)) → __¹(X, __(Y, Z))
ACTIVE(__(__(X, Y), Z)) → __¹(Y, Z)
ACTIVE(U11(tt)) → U12¹(tt)
ACTIVE(isNePal(__(I, __(P, I)))) → U11¹(tt)
ACTIVE(__(X1, X2)) → __¹(active(X1), X2)
ACTIVE(__(X1, X2)) → ACTIVE(X1)
ACTIVE(__(X1, X2)) → __¹(X1, active(X2))
ACTIVE(__(X1, X2)) → ACTIVE(X2)
ACTIVE(U11(X)) → U11¹(active(X))
ACTIVE(U11(X)) → ACTIVE(X)
ACTIVE(U12(X)) → U12¹(active(X))
ACTIVE(U12(X)) → ACTIVE(X)
ACTIVE(isNePal(X)) → ISNEPAL(active(X))
ACTIVE(isNePal(X)) → ACTIVE(X)
__¹(mark(X1), X2) → __¹(X1, X2)
__¹(X1, mark(X2)) → __¹(X1, X2)
U11¹(mark(X)) → U11¹(X)
U12¹(mark(X)) → U12¹(X)
ISNEPAL(mark(X)) → ISNEPAL(X)
PROPER(__(X1, X2)) → __¹(proper(X1), proper(X2))
PROPER(__(X1, X2)) → PROPER(X1)
PROPER(__(X1, X2)) → PROPER(X2)
PROPER(U11(X)) → U11¹(proper(X))
PROPER(U11(X)) → PROPER(X)
PROPER(U12(X)) → U12¹(proper(X))
PROPER(U12(X)) → PROPER(X)
PROPER(isNePal(X)) → ISNEPAL(proper(X))
PROPER(isNePal(X)) → PROPER(X)
__¹(ok(X1), ok(X2)) → __¹(X1, X2)
U11¹(ok(X)) → U11¹(X)
U12¹(ok(X)) → U12¹(X)
ISNEPAL(ok(X)) → ISNEPAL(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(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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 7 SCCs with 15 less nodes.

(4) Complex Obligation (AND)

(5) Obligation:

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

ISNEPAL(ok(X)) → ISNEPAL(X)
ISNEPAL(mark(X)) → ISNEPAL(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

ISNEPAL(mark(X)) → ISNEPAL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNEPAL(x1) = ISNEPAL(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = isNePal(x1)
proper(x1) = x1
top(x1) = top(x1)

Lexicographic path order with status [LPO].
Precedence:

__₂ > mark₁ > ISNEPAL₁
nil > mark₁ > ISNEPAL₁
isNePal₁ > U11₁ > tt > mark₁ > ISNEPAL₁
isNePal₁ > U11₁ > U12₁ > mark₁ > ISNEPAL₁

Status:

top₁: [1]
__₂: [1,2]
tt: []
mark₁: [1]
U12₁: [1]
U11₁: [1]
isNePal₁: [1]
nil: []
ISNEPAL₁: [1]

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(7) Obligation:

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

ISNEPAL(ok(X)) → ISNEPAL(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ISNEPAL(ok(X)) → ISNEPAL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNEPAL(x1) = ISNEPAL(x1)
ok(x1) = ok(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
mark(x1) = x1
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

proper₁ > __₂ > U11₁ > U12₁ > ok₁
proper₁ > __₂ > U11₁ > U12₁ > tt
proper₁ > nil > ok₁

Status:

__₂: [1,2]
tt: []
ok₁: [1]
U12₁: [1]
U11₁: [1]
proper₁: [1]
top: []
nil: []
ISNEPAL₁: [1]

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(9) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(10) PisEmptyProof (EQUIVALENT transformation)

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

(11) TRUE

(12) Obligation:

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

U12¹(ok(X)) → U12¹(X)
U12¹(mark(X)) → U12¹(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

U12¹(mark(X)) → U12¹(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U12¹(x1) = U12¹(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = isNePal(x1)
proper(x1) = x1
top(x1) = top(x1)

Lexicographic path order with status [LPO].
Precedence:

__₂ > mark₁ > U12^1₁
nil > mark₁ > U12^1₁
isNePal₁ > U11₁ > tt > mark₁ > U12^1₁
isNePal₁ > U11₁ > U12₁ > mark₁ > U12^1₁

Status:

top₁: [1]
U12^1₁: [1]
__₂: [1,2]
tt: []
mark₁: [1]
U12₁: [1]
U11₁: [1]
isNePal₁: [1]
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(14) Obligation:

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

U12¹(ok(X)) → U12¹(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U12¹(ok(X)) → U12¹(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U12¹(x1) = U12¹(x1)
ok(x1) = ok(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
mark(x1) = x1
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

proper₁ > __₂ > U11₁ > U12₁ > ok₁
proper₁ > __₂ > U11₁ > U12₁ > tt
proper₁ > nil > ok₁

Status:

U12^1₁: [1]
__₂: [1,2]
tt: []
ok₁: [1]
U12₁: [1]
U11₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(16) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(17) PisEmptyProof (EQUIVALENT transformation)

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

(18) TRUE

(19) Obligation:

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

U11¹(ok(X)) → U11¹(X)
U11¹(mark(X)) → U11¹(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

U11¹(mark(X)) → U11¹(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U11¹(x1) = U11¹(x1)
ok(x1) = x1
mark(x1) = mark(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = isNePal(x1)
proper(x1) = x1
top(x1) = top(x1)

Lexicographic path order with status [LPO].
Precedence:

__₂ > mark₁ > U11^1₁
nil > mark₁ > U11^1₁
isNePal₁ > U11₁ > tt > mark₁ > U11^1₁
isNePal₁ > U11₁ > U12₁ > mark₁ > U11^1₁

Status:

top₁: [1]
U11^1₁: [1]
__₂: [1,2]
tt: []
mark₁: [1]
U12₁: [1]
U11₁: [1]
isNePal₁: [1]
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(21) Obligation:

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

U11¹(ok(X)) → U11¹(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U11¹(ok(X)) → U11¹(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U11¹(x1) = U11¹(x1)
ok(x1) = ok(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
mark(x1) = x1
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

proper₁ > __₂ > U11₁ > U12₁ > ok₁
proper₁ > __₂ > U11₁ > U12₁ > tt
proper₁ > nil > ok₁

Status:

U11^1₁: [1]
__₂: [1,2]
tt: []
ok₁: [1]
U12₁: [1]
U11₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(23) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(24) PisEmptyProof (EQUIVALENT transformation)

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

(25) TRUE

(26) Obligation:

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

__¹(X1, mark(X2)) → __¹(X1, X2)
__¹(mark(X1), X2) → __¹(X1, X2)
__¹(ok(X1), ok(X2)) → __¹(X1, X2)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

__¹(X1, mark(X2)) → __¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
__¹(x1, x2) = __¹(x2)
mark(x1) = mark(x1)
ok(x1) = x1
active(x1) = active(x1)
__(x1, x2) = __(x1, x2)
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

nil > mark₁ > __^1₁
top > active₁ > __₂ > mark₁ > __^1₁
top > active₁ > U11₁ > mark₁ > __^1₁
top > active₁ > tt > mark₁ > __^1₁
top > active₁ > U12₁ > mark₁ > __^1₁
top > proper₁ > __₂ > mark₁ > __^1₁
top > proper₁ > U11₁ > mark₁ > __^1₁
top > proper₁ > tt > mark₁ > __^1₁
top > proper₁ > U12₁ > mark₁ > __^1₁

Status:

active₁: [1]
__₂: [1,2]
tt: []
mark₁: [1]
U12₁: [1]
__^1₁: [1]
U11₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(28) Obligation:

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

__¹(mark(X1), X2) → __¹(X1, X2)
__¹(ok(X1), ok(X2)) → __¹(X1, X2)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

__¹(ok(X1), ok(X2)) → __¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
__¹(x1, x2) = __¹(x2)
mark(x1) = mark
ok(x1) = ok(x1)
active(x1) = x1
__(x1, x2) = __(x1)
nil = nil
U11(x1) = x1
tt = tt
U12(x1) = x1
isNePal(x1) = isNePal(x1)
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

nil > mark
nil > ok₁ > top
tt > mark
tt > ok₁ > top
proper₁ > __₁ > mark
proper₁ > __₁ > ok₁ > top
proper₁ > isNePal₁ > mark
proper₁ > isNePal₁ > ok₁ > top

Status:

__₁: [1]
tt: []
mark: []
ok₁: [1]
__^1₁: [1]
isNePal₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(30) Obligation:

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

__¹(mark(X1), X2) → __¹(X1, X2)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(31) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

__¹(mark(X1), X2) → __¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
__¹(x1, x2) = x1
mark(x1) = mark(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = isNePal(x1)
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

__₂ > mark₁
nil > mark₁
isNePal₁ > U11₁ > tt > U12₁ > mark₁
top > mark₁

Status:

tt: []
__₂: [1,2]
U12₁: [1]
mark₁: [1]
isNePal₁: [1]
U11₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(32) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(33) PisEmptyProof (EQUIVALENT transformation)

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

(34) TRUE

(35) Obligation:

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

PROPER(__(X1, X2)) → PROPER(X2)
PROPER(__(X1, X2)) → PROPER(X1)
PROPER(U11(X)) → PROPER(X)
PROPER(U12(X)) → PROPER(X)
PROPER(isNePal(X)) → PROPER(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

PROPER(__(X1, X2)) → PROPER(X2)
PROPER(__(X1, X2)) → PROPER(X1)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = PROPER(x1)
__(x1, x2) = __(x1, x2)
U11(x1) = x1
U12(x1) = x1
isNePal(x1) = x1
active(x1) = x1
mark(x1) = x1
nil = nil
tt = tt
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

nil > ok > __₂ > tt
top > proper₁ > ok > __₂ > tt

Status:

PROPER₁: [1]
tt: []
__₂: [1,2]
ok: []
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(37) Obligation:

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

PROPER(U11(X)) → PROPER(X)
PROPER(U12(X)) → PROPER(X)
PROPER(isNePal(X)) → PROPER(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(isNePal(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)
U11(x1) = x1
U12(x1) = x1
isNePal(x1) = isNePal(x1)
active(x1) = active(x1)
__(x1, x2) = __(x1, x2)
mark(x1) = mark
nil = nil
tt = tt
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

active₁ > isNePal₁ > PROPER₁ > top
active₁ > isNePal₁ > tt > mark > top
active₁ > isNePal₁ > ok > __₂ > top
proper₁ > isNePal₁ > PROPER₁ > top
proper₁ > isNePal₁ > tt > mark > top
proper₁ > isNePal₁ > ok > __₂ > top
proper₁ > nil > top

Status:

PROPER₁: [1]
active₁: [1]
__₂: [2,1]
tt: []
mark: []
isNePal₁: [1]
ok: []
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(39) Obligation:

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

PROPER(U11(X)) → PROPER(X)
PROPER(U12(X)) → PROPER(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(40) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(U12(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)
U11(x1) = x1
U12(x1) = U12(x1)
active(x1) = active(x1)
__(x1, x2) = __(x2)
mark(x1) = mark
nil = nil
tt = tt
isNePal(x1) = x1
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

PROPER₁ > top
active₁ > __₁ > mark > U12₁ > top
active₁ > __₁ > tt > U12₁ > top
proper₁ > __₁ > mark > U12₁ > top
proper₁ > __₁ > tt > U12₁ > top
proper₁ > nil > top

Status:

__₁: [1]
PROPER₁: [1]
active₁: [1]
tt: []
mark: []
U12₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(41) Obligation:

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

PROPER(U11(X)) → PROPER(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(42) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(U11(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1) = x1
U11(x1) = U11(x1)
active(x1) = active(x1)
__(x1, x2) = x1
mark(x1) = mark
nil = nil
tt = tt
U12(x1) = x1
isNePal(x1) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

top > active₁ > U11₁ > tt > mark
top > proper₁ > U11₁ > tt > mark
top > proper₁ > nil > mark
top > proper₁ > ok > mark

Status:

active₁: [1]
tt: []
mark: []
ok: []
U11₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(43) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(44) PisEmptyProof (EQUIVALENT transformation)

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

(45) TRUE

(46) Obligation:

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

ACTIVE(__(X1, X2)) → ACTIVE(X2)
ACTIVE(__(X1, X2)) → ACTIVE(X1)
ACTIVE(U11(X)) → ACTIVE(X)
ACTIVE(U12(X)) → ACTIVE(X)
ACTIVE(isNePal(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(47) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(__(X1, X2)) → ACTIVE(X2)
ACTIVE(__(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)
__(x1, x2) = __(x1, x2)
U11(x1) = x1
U12(x1) = x1
isNePal(x1) = x1
active(x1) = x1
mark(x1) = x1
nil = nil
tt = tt
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

nil > ok > __₂ > tt
top > proper₁ > ok > __₂ > tt

Status:

tt: []
__₂: [1,2]
ok: []
proper₁: [1]
top: []
nil: []
ACTIVE₁: [1]

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(48) Obligation:

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

ACTIVE(U11(X)) → ACTIVE(X)
ACTIVE(U12(X)) → ACTIVE(X)
ACTIVE(isNePal(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(49) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(isNePal(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)
U11(x1) = x1
U12(x1) = x1
isNePal(x1) = isNePal(x1)
active(x1) = active(x1)
__(x1, x2) = __(x1, x2)
mark(x1) = mark
nil = nil
tt = tt
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

active₁ > isNePal₁ > ACTIVE₁ > top
active₁ > isNePal₁ > tt > mark > top
active₁ > isNePal₁ > ok > __₂ > top
proper₁ > isNePal₁ > ACTIVE₁ > top
proper₁ > isNePal₁ > tt > mark > top
proper₁ > isNePal₁ > ok > __₂ > top
proper₁ > nil > top

Status:

active₁: [1]
__₂: [2,1]
tt: []
mark: []
isNePal₁: [1]
ok: []
proper₁: [1]
top: []
ACTIVE₁: [1]
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(50) Obligation:

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

ACTIVE(U11(X)) → ACTIVE(X)
ACTIVE(U12(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(51) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(U12(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)
U11(x1) = x1
U12(x1) = U12(x1)
active(x1) = active(x1)
__(x1, x2) = __(x2)
mark(x1) = mark
nil = nil
tt = tt
isNePal(x1) = x1
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

ACTIVE₁ > top
active₁ > __₁ > mark > U12₁ > top
active₁ > __₁ > tt > U12₁ > top
proper₁ > __₁ > mark > U12₁ > top
proper₁ > __₁ > tt > U12₁ > top
proper₁ > nil > top

Status:

__₁: [1]
active₁: [1]
tt: []
mark: []
U12₁: [1]
proper₁: [1]
top: []
ACTIVE₁: [1]
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(52) Obligation:

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

ACTIVE(U11(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(53) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(U11(X)) → ACTIVE(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = x1
U11(x1) = U11(x1)
active(x1) = active(x1)
__(x1, x2) = x1
mark(x1) = mark
nil = nil
tt = tt
U12(x1) = x1
isNePal(x1) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

top > active₁ > U11₁ > tt > mark
top > proper₁ > U11₁ > tt > mark
top > proper₁ > nil > mark
top > proper₁ > ok > mark

Status:

active₁: [1]
tt: []
mark: []
ok: []
U11₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(54) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(55) PisEmptyProof (EQUIVALENT transformation)

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

(56) TRUE

(57) 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(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(58) 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
__(x1, x2) = __(x1, x2)
nil = nil
U11(x1) = U11(x1)
tt = tt
U12(x1) = U12(x1)
isNePal(x1) = isNePal(x1)
top(x1) = top(x1)

Lexicographic path order with status [LPO].
Precedence:

__₂ > U11₁ > U12₁ > mark₁
isNePal₁ > U11₁ > U12₁ > mark₁
isNePal₁ > tt > U12₁ > mark₁

Status:

top₁: [1]
tt: []
__₂: [1,2]
U12₁: [1]
mark₁: [1]
isNePal₁: [1]
U11₁: [1]
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(59) 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(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(60) 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
__(x1, x2) = x2
mark(x1) = mark
nil = nil
U11(x1) = x1
tt = tt
U12(x1) = x1
isNePal(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

Lexicographic path order with status [LPO].
Precedence:

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

Status:

tt: []
mark: []
ok₁: [1]
TOP₁: [1]
proper₁: [1]
top: []
nil: []

The following usable rules [FROCOS05] were oriented:

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(61) Obligation:

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

active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
active(__(X, nil)) → mark(X)
active(__(nil, X)) → mark(X)
active(U11(tt)) → mark(U12(tt))
active(U12(tt)) → mark(tt)
active(isNePal(__(I, __(P, I)))) → mark(U11(tt))
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(U11(X)) → U11(active(X))
active(U12(X)) → U12(active(X))
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
U11(mark(X)) → mark(U11(X))
U12(mark(X)) → mark(U12(X))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U11(X)) → U11(proper(X))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
U11(ok(X)) → ok(U11(X))
U12(ok(X)) → ok(U12(X))
isNePal(ok(X)) → ok(isNePal(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.

(62) 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) QDPOrderProof (EQUIVALENT transformation)

(9) Obligation:

(10) PisEmptyProof (EQUIVALENT transformation)

(11) TRUE

(12) Obligation:

(13) QDPOrderProof (EQUIVALENT transformation)

(14) Obligation:

(15) QDPOrderProof (EQUIVALENT transformation)

(16) Obligation:

(17) PisEmptyProof (EQUIVALENT transformation)

(18) TRUE

(19) Obligation:

(20) QDPOrderProof (EQUIVALENT transformation)

(21) Obligation:

(22) QDPOrderProof (EQUIVALENT transformation)

(23) Obligation:

(24) PisEmptyProof (EQUIVALENT transformation)

(25) TRUE

(26) Obligation:

(27) QDPOrderProof (EQUIVALENT transformation)

(28) Obligation:

(29) QDPOrderProof (EQUIVALENT transformation)

(30) Obligation:

(31) QDPOrderProof (EQUIVALENT transformation)

(32) Obligation:

(33) PisEmptyProof (EQUIVALENT transformation)

(34) TRUE

(35) Obligation:

(36) QDPOrderProof (EQUIVALENT transformation)

(37) Obligation:

(38) QDPOrderProof (EQUIVALENT transformation)

(39) Obligation:

(40) QDPOrderProof (EQUIVALENT transformation)

(41) Obligation:

(42) QDPOrderProof (EQUIVALENT transformation)

(43) Obligation:

(44) PisEmptyProof (EQUIVALENT transformation)

(45) TRUE

(46) Obligation:

(47) QDPOrderProof (EQUIVALENT transformation)

(48) Obligation:

(49) QDPOrderProof (EQUIVALENT transformation)

(50) Obligation:

(51) QDPOrderProof (EQUIVALENT transformation)

(52) Obligation:

(53) QDPOrderProof (EQUIVALENT transformation)

(54) Obligation:

(55) PisEmptyProof (EQUIVALENT transformation)

(56) TRUE

(57) Obligation:

(58) QDPOrderProof (EQUIVALENT transformation)

(59) Obligation:

(60) QDPOrderProof (EQUIVALENT transformation)

(61) Obligation:

(62) PisEmptyProof (EQUIVALENT transformation)

(63) TRUE