Termination w.r.t. Q proof of /tmp/tmpoXE5MY/PALINDROME_nosorts

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

    ↳25 QDP

    ↳26 PisEmptyProof (⇔)

    ↳27 TRUE

  ↳28 QDP

    ↳29 QDPOrderProof (⇔)

    ↳30 QDP

    ↳31 QDPOrderProof (⇔)

    ↳32 QDP

    ↳33 PisEmptyProof (⇔)

    ↳34 TRUE

  ↳35 QDP

    ↳36 QDPOrderProof (⇔)

    ↳37 QDP

    ↳38 PisEmptyProof (⇔)

    ↳39 TRUE

  ↳40 QDP

    ↳41 QDPOrderProof (⇔)

    ↳42 QDP

    ↳43 QDPOrderProof (⇔)

    ↳44 QDP

    ↳45 PisEmptyProof (⇔)

    ↳46 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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(__(X1, X2)) → __¹(active(X1), X2)
ACTIVE(__(X1, X2)) → ACTIVE(X1)
ACTIVE(__(X1, X2)) → __¹(X1, active(X2))
ACTIVE(__(X1, X2)) → ACTIVE(X2)
ACTIVE(and(X1, X2)) → AND(active(X1), X2)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(isNePal(X)) → ISNEPAL(active(X))
ACTIVE(isNePal(X)) → ACTIVE(X)
__¹(mark(X1), X2) → __¹(X1, X2)
__¹(X1, mark(X2)) → __¹(X1, X2)
AND(mark(X1), X2) → AND(X1, X2)
ISNEPAL(mark(X)) → ISNEPAL(X)
PROPER(__(X1, X2)) → __¹(proper(X1), proper(X2))
PROPER(__(X1, X2)) → PROPER(X1)
PROPER(__(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → AND(proper(X1), proper(X2))
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(isNePal(X)) → ISNEPAL(proper(X))
PROPER(isNePal(X)) → PROPER(X)
__¹(ok(X1), ok(X2)) → __¹(X1, X2)
AND(ok(X1), ok(X2)) → AND(X1, X2)
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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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 6 SCCs with 11 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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(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)
mark(x1) = x1
active(x1) = active(x1)
__(x1, x2) = __(x1, x2)
nil = nil
and(x1, x2) = and(x1, x2)
tt = tt
isNePal(x1) = x1
proper(x1) = proper(x1)
top(x1) = top

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

[active₁, tt] > __₂ > ok₁
[active₁, tt] > and₂ > ok₁
proper₁ > __₂ > ok₁
proper₁ > nil > ok₁
proper₁ > and₂ > ok₁

Status:

ISNEPAL₁: [1]
ok₁: [1]
active₁: [1]
__₂: multiset
nil: multiset
and₂: multiset
tt: multiset
proper₁: multiset
top: []

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(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) = x1
mark(x1) = mark(x1)
active(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
and(x1, x2) = and(x1, x2)
tt = tt
isNePal(x1) = isNePal(x1)
proper(x1) = x1
ok(x1) = x1
top(x1) = x1

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

__₂ > mark₁ > tt
nil > mark₁ > tt
and₂ > mark₁ > tt
isNePal₁ > mark₁ > tt

Status:

mark₁: [1]
__₂: [1,2]
nil: multiset
and₂: [1,2]
tt: multiset
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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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:

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

AND(ok(X1), ok(X2)) → AND(X1, X2)

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

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

[isNePal₁, proper₁] > [AND₁, ok₁, and₁] > top > [mark, nil]
[isNePal₁, proper₁] > tt > [mark, nil]

Status:

AND₁: multiset
ok₁: [1]
mark: multiset
nil: multiset
and₁: [1]
tt: multiset
isNePal₁: multiset
proper₁: multiset
top: multiset

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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:

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

AND(mark(X1), X2) → AND(X1, X2)

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

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

AND₁ > mark₁
[nil, and₂, proper₁] > __₂ > tt > mark₁
[nil, and₂, proper₁] > __₂ > ok₁ > mark₁
top > mark₁

Status:

AND₁: multiset
mark₁: multiset
__₂: [1,2]
nil: multiset
and₂: [1,2]
tt: multiset
proper₁: [1]
ok₁: multiset
top: []

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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:

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

__¹(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)
ok(x1) = x1
active(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
and(x1, x2) = and(x1, x2)
tt = tt
isNePal(x1) = isNePal(x1)
proper(x1) = x1
top(x1) = top(x1)

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

__₂ > mark₁ > __^1₁
nil > mark₁ > __^1₁
and₂ > mark₁ > __^1₁
[tt, isNePal₁] > mark₁ > __^1₁
top₁ > __^1₁

Status:

__^1₁: multiset
mark₁: [1]
__₂: [1,2]
nil: multiset
and₂: [1,2]
tt: multiset
isNePal₁: [1]
top₁: multiset

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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:

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

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

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

__^1₁ > [mark, nil]
proper > ok₁ > [mark, nil]
proper > tt > [mark, nil]
top > [mark, nil]

Status:

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

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(23) Obligation:

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

__¹(X1, mark(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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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) 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)
active(x1) = active(x1)
__(x1, x2) = __(x1, x2)
nil = nil
and(x1, x2) = and(x1, x2)
tt = tt
isNePal(x1) = x1
proper(x1) = x1
ok(x1) = ok
top(x1) = top

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

[active₁, tt, top] > __₂ > mark₁
[active₁, tt, top] > __₂ > ok
[active₁, tt, top] > and₂ > mark₁
[active₁, tt, top] > and₂ > ok
nil > mark₁
nil > ok

Status:

mark₁: multiset
active₁: [1]
__₂: [2,1]
nil: multiset
and₂: [2,1]
tt: multiset
ok: multiset
top: []

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNePal(ok(X)) → ok(isNePal(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(26) PisEmptyProof (EQUIVALENT transformation)

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

(27) TRUE

(28) Obligation:

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

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

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

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

[PROPER₁, and₂, proper₁, ok, top] > __₂ > tt
[PROPER₁, and₂, proper₁, ok, top] > nil

Status:

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

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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:

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

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

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

isNePal₁ > [_{_₂}, tt]

Status:

PROPER₁: [1]
isNePal₁: [1]
__₂: [1,2]
nil: multiset
tt: multiset

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
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:

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

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

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

nil > [ACTIVE₁, and₂, isNePal₁, tt]
top > [_{_₂}, proper₁] > [ACTIVE₁, and₂, isNePal₁, tt]

Status:

ACTIVE₁: multiset
__₂: [1,2]
and₂: [2,1]
isNePal₁: [1]
nil: multiset
tt: multiset
proper₁: [1]
top: []

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

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

(41) 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) = TOP(x1)
ok(x1) = x1
active(x1) = x1
mark(x1) = mark(x1)
proper(x1) = x1
__(x1, x2) = __(x1, x2)
nil = nil
and(x1, x2) = and(x1, x2)
tt = tt
isNePal(x1) = isNePal(x1)
top(x1) = x1

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

__₂ > [tt, isNePal₁] > mark₁ > TOP₁
and₂ > mark₁ > TOP₁

Status:

TOP₁: multiset
mark₁: [1]
__₂: [1,2]
nil: multiset
and₂: multiset
tt: multiset
isNePal₁: multiset

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(and(tt, X)) → mark(X)
active(isNePal(__(I, __(P, I)))) → mark(tt)
active(__(X1, X2)) → __(active(X1), X2)
active(__(X1, X2)) → __(X1, active(X2))
active(and(X1, X2)) → and(active(X1), X2)
active(isNePal(X)) → isNePal(active(X))
__(mark(X1), X2) → mark(__(X1, X2))
__(X1, mark(X2)) → mark(__(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
isNePal(mark(X)) → mark(isNePal(X))
proper(__(X1, X2)) → __(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNePal(X)) → isNePal(proper(X))
__(ok(X1), ok(X2)) → ok(__(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNePal(ok(X)) → ok(isNePal(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:

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

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

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

[nil, isNePal₁, proper₁] > __₂ > [ok₁, top]
[nil, isNePal₁, proper₁] > and₂ > [ok₁, top]
[nil, isNePal₁, proper₁] > tt > [ok₁, top]

Status:

ok₁: [1]
__₂: [1,2]
nil: multiset
and₂: [1,2]
tt: multiset
isNePal₁: [1]
proper₁: [1]
top: []

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

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

(25) Obligation:

(26) PisEmptyProof (EQUIVALENT transformation)

(27) TRUE

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