(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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)) → MARK(__(X, __(Y, Z)))
ACTIVE(__(__(X, Y), Z)) → __1(X, __(Y, Z))
ACTIVE(__(__(X, Y), Z)) → __1(Y, Z)
ACTIVE(__(X, nil)) → MARK(X)
ACTIVE(__(nil, X)) → MARK(X)
ACTIVE(U11(tt)) → MARK(tt)
ACTIVE(U21(tt, V2)) → MARK(U22(isList(V2)))
ACTIVE(U21(tt, V2)) → U221(isList(V2))
ACTIVE(U21(tt, V2)) → ISLIST(V2)
ACTIVE(U22(tt)) → MARK(tt)
ACTIVE(U31(tt)) → MARK(tt)
ACTIVE(U41(tt, V2)) → MARK(U42(isNeList(V2)))
ACTIVE(U41(tt, V2)) → U421(isNeList(V2))
ACTIVE(U41(tt, V2)) → ISNELIST(V2)
ACTIVE(U42(tt)) → MARK(tt)
ACTIVE(U51(tt, V2)) → MARK(U52(isList(V2)))
ACTIVE(U51(tt, V2)) → U521(isList(V2))
ACTIVE(U51(tt, V2)) → ISLIST(V2)
ACTIVE(U52(tt)) → MARK(tt)
ACTIVE(U61(tt)) → MARK(tt)
ACTIVE(U71(tt, P)) → MARK(U72(isPal(P)))
ACTIVE(U71(tt, P)) → U721(isPal(P))
ACTIVE(U71(tt, P)) → ISPAL(P)
ACTIVE(U72(tt)) → MARK(tt)
ACTIVE(U81(tt)) → MARK(tt)
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
ACTIVE(isList(V)) → U111(isNeList(V))
ACTIVE(isList(V)) → ISNELIST(V)
ACTIVE(isList(nil)) → MARK(tt)
ACTIVE(isList(__(V1, V2))) → MARK(U21(isList(V1), V2))
ACTIVE(isList(__(V1, V2))) → U211(isList(V1), V2)
ACTIVE(isList(__(V1, V2))) → ISLIST(V1)
ACTIVE(isNeList(V)) → MARK(U31(isQid(V)))
ACTIVE(isNeList(V)) → U311(isQid(V))
ACTIVE(isNeList(V)) → ISQID(V)
ACTIVE(isNeList(__(V1, V2))) → MARK(U41(isList(V1), V2))
ACTIVE(isNeList(__(V1, V2))) → U411(isList(V1), V2)
ACTIVE(isNeList(__(V1, V2))) → ISLIST(V1)
ACTIVE(isNeList(__(V1, V2))) → MARK(U51(isNeList(V1), V2))
ACTIVE(isNeList(__(V1, V2))) → U511(isNeList(V1), V2)
ACTIVE(isNeList(__(V1, V2))) → ISNELIST(V1)
ACTIVE(isNePal(V)) → MARK(U61(isQid(V)))
ACTIVE(isNePal(V)) → U611(isQid(V))
ACTIVE(isNePal(V)) → ISQID(V)
ACTIVE(isNePal(__(I, __(P, I)))) → MARK(U71(isQid(I), P))
ACTIVE(isNePal(__(I, __(P, I)))) → U711(isQid(I), P)
ACTIVE(isNePal(__(I, __(P, I)))) → ISQID(I)
ACTIVE(isPal(V)) → MARK(U81(isNePal(V)))
ACTIVE(isPal(V)) → U811(isNePal(V))
ACTIVE(isPal(V)) → ISNEPAL(V)
ACTIVE(isPal(nil)) → MARK(tt)
ACTIVE(isQid(a)) → MARK(tt)
ACTIVE(isQid(e)) → MARK(tt)
ACTIVE(isQid(i)) → MARK(tt)
ACTIVE(isQid(o)) → MARK(tt)
ACTIVE(isQid(u)) → MARK(tt)
MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(__(X1, X2)) → __1(mark(X1), mark(X2))
MARK(__(X1, X2)) → MARK(X1)
MARK(__(X1, X2)) → MARK(X2)
MARK(nil) → ACTIVE(nil)
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U11(X)) → U111(mark(X))
MARK(U11(X)) → MARK(X)
MARK(tt) → ACTIVE(tt)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U21(X1, X2)) → U211(mark(X1), X2)
MARK(U21(X1, X2)) → MARK(X1)
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(U22(X)) → U221(mark(X))
MARK(U22(X)) → MARK(X)
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U31(X)) → U311(mark(X))
MARK(U31(X)) → MARK(X)
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U41(X1, X2)) → U411(mark(X1), X2)
MARK(U41(X1, X2)) → MARK(X1)
MARK(U42(X)) → ACTIVE(U42(mark(X)))
MARK(U42(X)) → U421(mark(X))
MARK(U42(X)) → MARK(X)
MARK(isNeList(X)) → ACTIVE(isNeList(X))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
MARK(U51(X1, X2)) → U511(mark(X1), X2)
MARK(U51(X1, X2)) → MARK(X1)
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U52(X)) → U521(mark(X))
MARK(U52(X)) → MARK(X)
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U61(X)) → U611(mark(X))
MARK(U61(X)) → MARK(X)
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
MARK(U71(X1, X2)) → U711(mark(X1), X2)
MARK(U71(X1, X2)) → MARK(X1)
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(U72(X)) → U721(mark(X))
MARK(U72(X)) → MARK(X)
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(U81(X)) → U811(mark(X))
MARK(U81(X)) → MARK(X)
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(isNePal(X))
MARK(a) → ACTIVE(a)
MARK(e) → ACTIVE(e)
MARK(i) → ACTIVE(i)
MARK(o) → ACTIVE(o)
MARK(u) → ACTIVE(u)
__1(mark(X1), X2) → __1(X1, X2)
__1(X1, mark(X2)) → __1(X1, X2)
__1(active(X1), X2) → __1(X1, X2)
__1(X1, active(X2)) → __1(X1, X2)
U111(mark(X)) → U111(X)
U111(active(X)) → U111(X)
U211(mark(X1), X2) → U211(X1, X2)
U211(X1, mark(X2)) → U211(X1, X2)
U211(active(X1), X2) → U211(X1, X2)
U211(X1, active(X2)) → U211(X1, X2)
U221(mark(X)) → U221(X)
U221(active(X)) → U221(X)
ISLIST(mark(X)) → ISLIST(X)
ISLIST(active(X)) → ISLIST(X)
U311(mark(X)) → U311(X)
U311(active(X)) → U311(X)
U411(mark(X1), X2) → U411(X1, X2)
U411(X1, mark(X2)) → U411(X1, X2)
U411(active(X1), X2) → U411(X1, X2)
U411(X1, active(X2)) → U411(X1, X2)
U421(mark(X)) → U421(X)
U421(active(X)) → U421(X)
ISNELIST(mark(X)) → ISNELIST(X)
ISNELIST(active(X)) → ISNELIST(X)
U511(mark(X1), X2) → U511(X1, X2)
U511(X1, mark(X2)) → U511(X1, X2)
U511(active(X1), X2) → U511(X1, X2)
U511(X1, active(X2)) → U511(X1, X2)
U521(mark(X)) → U521(X)
U521(active(X)) → U521(X)
U611(mark(X)) → U611(X)
U611(active(X)) → U611(X)
U711(mark(X1), X2) → U711(X1, X2)
U711(X1, mark(X2)) → U711(X1, X2)
U711(active(X1), X2) → U711(X1, X2)
U711(X1, active(X2)) → U711(X1, X2)
U721(mark(X)) → U721(X)
U721(active(X)) → U721(X)
ISPAL(mark(X)) → ISPAL(X)
ISPAL(active(X)) → ISPAL(X)
U811(mark(X)) → U811(X)
U811(active(X)) → U811(X)
ISQID(mark(X)) → ISQID(X)
ISQID(active(X)) → ISQID(X)
ISNEPAL(mark(X)) → ISNEPAL(X)
ISNEPAL(active(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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 19 SCCs with 61 less nodes.

(4) Complex Obligation (AND)

(5) Obligation:

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

ISNEPAL(active(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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(active(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)
active(x1)  =  active(x1)
mark(x1)  =  x1

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

Status:
ISNEPAL1: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(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(U11(tt)) → mark(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > ISNEPAL1

Status:
ISNEPAL1: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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:

ISQID(active(X)) → ISQID(X)
ISQID(mark(X)) → ISQID(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


ISQID(active(X)) → ISQID(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISQID(x1)  =  ISQID(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

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

Status:
ISQID1: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(14) Obligation:

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

ISQID(mark(X)) → ISQID(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


ISQID(mark(X)) → ISQID(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > ISQID1

Status:
ISQID1: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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:

U811(active(X)) → U811(X)
U811(mark(X)) → U811(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


U811(active(X)) → U811(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U811(x1)  =  U811(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U81^11, active1]

Status:
U81^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(21) Obligation:

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

U811(mark(X)) → U811(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


U811(mark(X)) → U811(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U81^11

Status:
U81^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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:

ISPAL(active(X)) → ISPAL(X)
ISPAL(mark(X)) → ISPAL(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


ISPAL(active(X)) → ISPAL(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISPAL(x1)  =  ISPAL(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

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

Status:
ISPAL1: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(28) Obligation:

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

ISPAL(mark(X)) → ISPAL(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


ISPAL(mark(X)) → ISPAL(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > ISPAL1

Status:
ISPAL1: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(30) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(31) PisEmptyProof (EQUIVALENT transformation)

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

(32) TRUE

(33) Obligation:

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

U721(active(X)) → U721(X)
U721(mark(X)) → U721(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(34) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U721(active(X)) → U721(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U721(x1)  =  U721(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U72^11, active1]

Status:
U72^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(35) Obligation:

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

U721(mark(X)) → U721(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


U721(mark(X)) → U721(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U72^11

Status:
U72^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(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(U11(tt)) → mark(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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:

U711(X1, mark(X2)) → U711(X1, X2)
U711(mark(X1), X2) → U711(X1, X2)
U711(active(X1), X2) → U711(X1, X2)
U711(X1, active(X2)) → U711(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


U711(X1, active(X2)) → U711(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U711(x1, x2)  =  x2
mark(x1)  =  x1
active(x1)  =  active(x1)

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

Status:
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(42) Obligation:

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

U711(X1, mark(X2)) → U711(X1, X2)
U711(mark(X1), X2) → U711(X1, X2)
U711(active(X1), X2) → U711(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


U711(X1, mark(X2)) → U711(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U711(x1, x2)  =  U711(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active

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

Status:
U71^11: [1]
mark1: [1]
active: multiset


The following usable rules [FROCOS05] were oriented: none

(44) Obligation:

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

U711(mark(X1), X2) → U711(X1, X2)
U711(active(X1), X2) → U711(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(45) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U711(mark(X1), X2) → U711(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U711(x1, x2)  =  U711(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U71^12, mark1]

Status:
U71^12: [2,1]
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(46) Obligation:

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

U711(active(X1), X2) → U711(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(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.


U711(active(X1), X2) → U711(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
trivial

Status:
U71^12: [1,2]
active1: [1]


The following usable rules [FROCOS05] were oriented: none

(48) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(49) PisEmptyProof (EQUIVALENT transformation)

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

(50) TRUE

(51) Obligation:

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

U611(active(X)) → U611(X)
U611(mark(X)) → U611(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(52) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U611(active(X)) → U611(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U611(x1)  =  U611(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U61^11, active1]

Status:
U61^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(53) Obligation:

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

U611(mark(X)) → U611(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(54) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U611(mark(X)) → U611(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U61^11

Status:
U61^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(55) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(56) PisEmptyProof (EQUIVALENT transformation)

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

(57) TRUE

(58) Obligation:

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

U521(active(X)) → U521(X)
U521(mark(X)) → U521(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(59) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U521(active(X)) → U521(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U521(x1)  =  U521(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U52^11, active1]

Status:
U52^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(60) Obligation:

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

U521(mark(X)) → U521(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(61) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U521(mark(X)) → U521(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U52^11

Status:
U52^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(62) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(63) PisEmptyProof (EQUIVALENT transformation)

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

(64) TRUE

(65) Obligation:

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

U511(X1, mark(X2)) → U511(X1, X2)
U511(mark(X1), X2) → U511(X1, X2)
U511(active(X1), X2) → U511(X1, X2)
U511(X1, active(X2)) → U511(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(66) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U511(X1, active(X2)) → U511(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U511(x1, x2)  =  x2
mark(x1)  =  x1
active(x1)  =  active(x1)

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

Status:
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(67) Obligation:

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

U511(X1, mark(X2)) → U511(X1, X2)
U511(mark(X1), X2) → U511(X1, X2)
U511(active(X1), X2) → U511(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(68) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U511(X1, mark(X2)) → U511(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U511(x1, x2)  =  U511(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active

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

Status:
U51^11: [1]
mark1: [1]
active: multiset


The following usable rules [FROCOS05] were oriented: none

(69) Obligation:

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

U511(mark(X1), X2) → U511(X1, X2)
U511(active(X1), X2) → U511(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(70) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U511(mark(X1), X2) → U511(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U511(x1, x2)  =  U511(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U51^12, mark1]

Status:
U51^12: [2,1]
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(71) Obligation:

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

U511(active(X1), X2) → U511(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(72) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U511(active(X1), X2) → U511(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
trivial

Status:
U51^12: [1,2]
active1: [1]


The following usable rules [FROCOS05] were oriented: none

(73) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(74) PisEmptyProof (EQUIVALENT transformation)

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

(75) TRUE

(76) Obligation:

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

ISNELIST(active(X)) → ISNELIST(X)
ISNELIST(mark(X)) → ISNELIST(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(77) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISNELIST(active(X)) → ISNELIST(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNELIST(x1)  =  ISNELIST(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

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

Status:
ISNELIST1: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(78) Obligation:

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

ISNELIST(mark(X)) → ISNELIST(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(79) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISNELIST(mark(X)) → ISNELIST(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > ISNELIST1

Status:
ISNELIST1: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(80) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(81) PisEmptyProof (EQUIVALENT transformation)

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

(82) TRUE

(83) Obligation:

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

U421(active(X)) → U421(X)
U421(mark(X)) → U421(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(84) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U421(active(X)) → U421(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U421(x1)  =  U421(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U42^11, active1]

Status:
U42^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(85) Obligation:

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

U421(mark(X)) → U421(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(86) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U421(mark(X)) → U421(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U42^11

Status:
U42^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(87) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(88) PisEmptyProof (EQUIVALENT transformation)

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

(89) TRUE

(90) Obligation:

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

U411(X1, mark(X2)) → U411(X1, X2)
U411(mark(X1), X2) → U411(X1, X2)
U411(active(X1), X2) → U411(X1, X2)
U411(X1, active(X2)) → U411(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(91) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U411(X1, active(X2)) → U411(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U411(x1, x2)  =  x2
mark(x1)  =  x1
active(x1)  =  active(x1)

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

Status:
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(92) Obligation:

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

U411(X1, mark(X2)) → U411(X1, X2)
U411(mark(X1), X2) → U411(X1, X2)
U411(active(X1), X2) → U411(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(93) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U411(X1, mark(X2)) → U411(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U411(x1, x2)  =  U411(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active

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

Status:
U41^11: [1]
mark1: [1]
active: multiset


The following usable rules [FROCOS05] were oriented: none

(94) Obligation:

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

U411(mark(X1), X2) → U411(X1, X2)
U411(active(X1), X2) → U411(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(95) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U411(mark(X1), X2) → U411(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U411(x1, x2)  =  U411(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U41^12, mark1]

Status:
U41^12: [2,1]
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(96) Obligation:

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

U411(active(X1), X2) → U411(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(97) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U411(active(X1), X2) → U411(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
trivial

Status:
U41^12: [1,2]
active1: [1]


The following usable rules [FROCOS05] were oriented: none

(98) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(99) PisEmptyProof (EQUIVALENT transformation)

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

(100) TRUE

(101) Obligation:

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

U311(active(X)) → U311(X)
U311(mark(X)) → U311(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(102) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U311(active(X)) → U311(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U311(x1)  =  U311(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U31^11, active1]

Status:
U31^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(103) Obligation:

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

U311(mark(X)) → U311(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(104) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U311(mark(X)) → U311(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U31^11

Status:
U31^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(105) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(106) PisEmptyProof (EQUIVALENT transformation)

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

(107) TRUE

(108) Obligation:

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

ISLIST(active(X)) → ISLIST(X)
ISLIST(mark(X)) → ISLIST(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(109) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISLIST(active(X)) → ISLIST(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISLIST(x1)  =  ISLIST(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

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

Status:
ISLIST1: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(110) Obligation:

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

ISLIST(mark(X)) → ISLIST(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(111) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISLIST(mark(X)) → ISLIST(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > ISLIST1

Status:
ISLIST1: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(112) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(113) PisEmptyProof (EQUIVALENT transformation)

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

(114) TRUE

(115) Obligation:

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

U221(active(X)) → U221(X)
U221(mark(X)) → U221(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(116) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U221(active(X)) → U221(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U221(x1)  =  U221(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U22^11, active1]

Status:
U22^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(117) Obligation:

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

U221(mark(X)) → U221(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(118) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U221(mark(X)) → U221(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U22^11

Status:
U22^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(119) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(120) PisEmptyProof (EQUIVALENT transformation)

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

(121) TRUE

(122) Obligation:

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

U211(X1, mark(X2)) → U211(X1, X2)
U211(mark(X1), X2) → U211(X1, X2)
U211(active(X1), X2) → U211(X1, X2)
U211(X1, active(X2)) → U211(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(123) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U211(X1, active(X2)) → U211(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U211(x1, x2)  =  x2
mark(x1)  =  x1
active(x1)  =  active(x1)

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

Status:
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(124) Obligation:

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

U211(X1, mark(X2)) → U211(X1, X2)
U211(mark(X1), X2) → U211(X1, X2)
U211(active(X1), X2) → U211(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(125) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U211(X1, mark(X2)) → U211(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U211(x1, x2)  =  U211(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active

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

Status:
U21^11: [1]
mark1: [1]
active: multiset


The following usable rules [FROCOS05] were oriented: none

(126) Obligation:

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

U211(mark(X1), X2) → U211(X1, X2)
U211(active(X1), X2) → U211(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(127) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U211(mark(X1), X2) → U211(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U211(x1, x2)  =  U211(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U21^12, mark1]

Status:
U21^12: [2,1]
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(128) Obligation:

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

U211(active(X1), X2) → U211(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(129) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U211(active(X1), X2) → U211(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
trivial

Status:
U21^12: [1,2]
active1: [1]


The following usable rules [FROCOS05] were oriented: none

(130) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(131) PisEmptyProof (EQUIVALENT transformation)

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

(132) TRUE

(133) Obligation:

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

U111(active(X)) → U111(X)
U111(mark(X)) → U111(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(134) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U111(active(X)) → U111(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U111(x1)  =  U111(x1)
active(x1)  =  active(x1)
mark(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[U11^11, active1]

Status:
U11^11: [1]
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(135) Obligation:

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

U111(mark(X)) → U111(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(136) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U111(mark(X)) → U111(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
mark1 > U11^11

Status:
U11^11: multiset
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(137) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(138) PisEmptyProof (EQUIVALENT transformation)

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

(139) TRUE

(140) Obligation:

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

__1(X1, mark(X2)) → __1(X1, X2)
__1(mark(X1), X2) → __1(X1, X2)
__1(active(X1), X2) → __1(X1, X2)
__1(X1, active(X2)) → __1(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(141) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


__1(X1, active(X2)) → __1(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
__1(x1, x2)  =  x2
mark(x1)  =  x1
active(x1)  =  active(x1)

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

Status:
active1: multiset


The following usable rules [FROCOS05] were oriented: none

(142) Obligation:

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

__1(X1, mark(X2)) → __1(X1, X2)
__1(mark(X1), X2) → __1(X1, X2)
__1(active(X1), X2) → __1(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(143) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


__1(X1, mark(X2)) → __1(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
__1(x1, x2)  =  __1(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active

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

Status:
_^11: [1]
mark1: [1]
active: multiset


The following usable rules [FROCOS05] were oriented: none

(144) Obligation:

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

__1(mark(X1), X2) → __1(X1, X2)
__1(active(X1), X2) → __1(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(145) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


__1(mark(X1), X2) → __1(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
__1(x1, x2)  =  __1(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  x1

Recursive path order with status [RPO].
Quasi-Precedence:
[^12, mark1]

Status:
_^12: [2,1]
mark1: multiset


The following usable rules [FROCOS05] were oriented: none

(146) Obligation:

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

__1(active(X1), X2) → __1(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(147) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


__1(active(X1), X2) → __1(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Recursive path order with status [RPO].
Quasi-Precedence:
trivial

Status:
_^12: [1,2]
active1: [1]


The following usable rules [FROCOS05] were oriented: none

(148) 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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(149) PisEmptyProof (EQUIVALENT transformation)

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

(150) TRUE

(151) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
ACTIVE(__(__(X, Y), Z)) → MARK(__(X, __(Y, Z)))
MARK(__(X1, X2)) → MARK(X1)
MARK(__(X1, X2)) → MARK(X2)
MARK(U11(X)) → ACTIVE(U11(mark(X)))
ACTIVE(__(X, nil)) → MARK(X)
MARK(U11(X)) → MARK(X)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
ACTIVE(__(nil, X)) → MARK(X)
MARK(U21(X1, X2)) → MARK(X1)
MARK(U22(X)) → ACTIVE(U22(mark(X)))
ACTIVE(U21(tt, V2)) → MARK(U22(isList(V2)))
MARK(U22(X)) → MARK(X)
MARK(isList(X)) → ACTIVE(isList(X))
ACTIVE(U41(tt, V2)) → MARK(U42(isNeList(V2)))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
ACTIVE(U51(tt, V2)) → MARK(U52(isList(V2)))
MARK(U31(X)) → MARK(X)
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
ACTIVE(U71(tt, P)) → MARK(U72(isPal(P)))
MARK(U41(X1, X2)) → MARK(X1)
MARK(U42(X)) → ACTIVE(U42(mark(X)))
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
MARK(U42(X)) → MARK(X)
MARK(isNeList(X)) → ACTIVE(isNeList(X))
ACTIVE(isList(__(V1, V2))) → MARK(U21(isList(V1), V2))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
ACTIVE(isNeList(V)) → MARK(U31(isQid(V)))
MARK(U51(X1, X2)) → MARK(X1)
MARK(U52(X)) → ACTIVE(U52(mark(X)))
ACTIVE(isNeList(__(V1, V2))) → MARK(U41(isList(V1), V2))
MARK(U52(X)) → MARK(X)
MARK(U61(X)) → ACTIVE(U61(mark(X)))
ACTIVE(isNeList(__(V1, V2))) → MARK(U51(isNeList(V1), V2))
MARK(U61(X)) → MARK(X)
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
ACTIVE(isNePal(V)) → MARK(U61(isQid(V)))
MARK(U71(X1, X2)) → MARK(X1)
MARK(U72(X)) → ACTIVE(U72(mark(X)))
ACTIVE(isNePal(__(I, __(P, I)))) → MARK(U71(isQid(I), P))
MARK(U72(X)) → MARK(X)
MARK(isPal(X)) → ACTIVE(isPal(X))
ACTIVE(isPal(V)) → MARK(U81(isNePal(V)))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(U81(X)) → MARK(X)
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(152) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(__(__(X, Y), Z)) → MARK(__(X, __(Y, Z)))
MARK(__(X1, X2)) → MARK(X1)
MARK(__(X1, X2)) → MARK(X2)
ACTIVE(__(X, nil)) → MARK(X)
ACTIVE(__(nil, X)) → MARK(X)
MARK(U21(X1, X2)) → MARK(X1)
ACTIVE(U21(tt, V2)) → MARK(U22(isList(V2)))
MARK(U22(X)) → MARK(X)
ACTIVE(U41(tt, V2)) → MARK(U42(isNeList(V2)))
ACTIVE(U51(tt, V2)) → MARK(U52(isList(V2)))
ACTIVE(U71(tt, P)) → MARK(U72(isPal(P)))
MARK(U41(X1, X2)) → MARK(X1)
MARK(U42(X)) → MARK(X)
MARK(U51(X1, X2)) → MARK(X1)
ACTIVE(isNeList(__(V1, V2))) → MARK(U41(isList(V1), V2))
MARK(U52(X)) → MARK(X)
ACTIVE(isNeList(__(V1, V2))) → MARK(U51(isNeList(V1), V2))
MARK(U61(X)) → MARK(X)
MARK(U71(X1, X2)) → MARK(X1)
ACTIVE(isNePal(__(I, __(P, I)))) → MARK(U71(isQid(I), P))
ACTIVE(isPal(V)) → MARK(U81(isNePal(V)))
MARK(U81(X)) → MARK(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
__(x1, x2)  =  __(x1, x2)
ACTIVE(x1)  =  ACTIVE(x1)
mark(x1)  =  x1
U11(x1)  =  x1
nil  =  nil
U21(x1, x2)  =  U21(x1, x2)
U22(x1)  =  U22(x1)
tt  =  tt
isList(x1)  =  x1
U41(x1, x2)  =  U41(x1, x2)
U42(x1)  =  U42(x1)
isNeList(x1)  =  x1
U31(x1)  =  x1
U51(x1, x2)  =  U51(x1, x2)
U52(x1)  =  U52(x1)
U71(x1, x2)  =  U71(x1, x2)
U72(x1)  =  x1
isPal(x1)  =  isPal(x1)
isQid(x1)  =  x1
U61(x1)  =  U61(x1)
isNePal(x1)  =  isNePal(x1)
U81(x1)  =  U81(x1)
active(x1)  =  x1
a  =  a
e  =  e
i  =  i
o  =  o
u  =  u

Recursive path order with status [RPO].
Quasi-Precedence:
[2, U212] > U412 > [MARK1, ACTIVE1] > U221 > U421
[2, U212] > U412 > [MARK1, ACTIVE1] > U521 > U421
[2, U212] > U412 > [MARK1, ACTIVE1] > U811 > U421
[2, U212] > U512 > [MARK1, ACTIVE1] > U221 > U421
[2, U212] > U512 > [MARK1, ACTIVE1] > U521 > U421
[2, U212] > U512 > [MARK1, ACTIVE1] > U811 > U421
[2, U212] > U712 > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U221 > U421
[2, U212] > U712 > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U521 > U421
[2, U212] > U712 > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U811 > U421
nil > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U221 > U421
nil > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U521 > U421
nil > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U811 > U421
e > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U221 > U421
e > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U521 > U421
e > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U811 > U421
i > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U221 > U421
i > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U521 > U421
i > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U811 > U421
o > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U221 > U421
o > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U521 > U421
o > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U811 > U421
u > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U221 > U421
u > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U521 > U421
u > [tt, isPal1, a] > [U611, isNePal1] > [MARK1, ACTIVE1] > U811 > U421

Status:
MARK1: [1]
_2: [1,2]
ACTIVE1: [1]
nil: multiset
U212: [1,2]
U221: [1]
tt: multiset
U412: multiset
U421: [1]
U512: [2,1]
U521: [1]
U712: [1,2]
isPal1: [1]
U611: [1]
isNePal1: [1]
U811: [1]
a: multiset
e: multiset
i: multiset
o: multiset
u: multiset


The following usable rules [FROCOS05] were oriented:

mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
mark(U11(X)) → active(U11(mark(X)))
active(__(X, nil)) → mark(X)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
active(__(nil, X)) → mark(X)
mark(U22(X)) → active(U22(mark(X)))
active(U21(tt, V2)) → mark(U22(isList(V2)))
mark(isList(X)) → active(isList(X))
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
mark(U31(X)) → active(U31(mark(X)))
active(U51(tt, V2)) → mark(U52(isList(V2)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
active(U71(tt, P)) → mark(U72(isPal(P)))
mark(U42(X)) → active(U42(mark(X)))
active(isList(V)) → mark(U11(isNeList(V)))
mark(isNeList(X)) → active(isNeList(X))
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
active(isNeList(V)) → mark(U31(isQid(V)))
mark(U52(X)) → active(U52(mark(X)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
mark(U61(X)) → active(U61(mark(X)))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
active(isNePal(V)) → mark(U61(isQid(V)))
mark(U72(X)) → active(U72(mark(X)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
mark(isPal(X)) → active(isPal(X))
active(isPal(V)) → mark(U81(isNePal(V)))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(nil) → active(nil)
mark(tt) → active(tt)
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(X1, mark(X2)) → __(X1, X2)
__(mark(X1), X2) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(active(X)) → U11(X)
U11(mark(X)) → U11(X)
U21(X1, mark(X2)) → U21(X1, X2)
U21(mark(X1), X2) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(active(X)) → U22(X)
U22(mark(X)) → U22(X)
isList(active(X)) → isList(X)
isList(mark(X)) → isList(X)
isNeList(active(X)) → isNeList(X)
isNeList(mark(X)) → isNeList(X)
U42(active(X)) → U42(X)
U42(mark(X)) → U42(X)
U31(active(X)) → U31(X)
U31(mark(X)) → U31(X)
U52(active(X)) → U52(X)
U52(mark(X)) → U52(X)
U41(X1, mark(X2)) → U41(X1, X2)
U41(mark(X1), X2) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
isPal(active(X)) → isPal(X)
isPal(mark(X)) → isPal(X)
U72(active(X)) → U72(X)
U72(mark(X)) → U72(X)
U51(X1, mark(X2)) → U51(X1, X2)
U51(mark(X1), X2) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
isQid(active(X)) → isQid(X)
isQid(mark(X)) → isQid(X)
U61(active(X)) → U61(X)
U61(mark(X)) → U61(X)
U71(X1, mark(X2)) → U71(X1, X2)
U71(mark(X1), X2) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
isNePal(active(X)) → isNePal(X)
isNePal(mark(X)) → isNePal(X)
U81(active(X)) → U81(X)
U81(mark(X)) → U81(X)
active(U11(tt)) → mark(tt)
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U42(tt)) → mark(tt)
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(nil)) → mark(tt)
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)

(153) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U11(X)) → MARK(X)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U31(X)) → MARK(X)
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U42(X)) → ACTIVE(U42(mark(X)))
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
MARK(isNeList(X)) → ACTIVE(isNeList(X))
ACTIVE(isList(__(V1, V2))) → MARK(U21(isList(V1), V2))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
ACTIVE(isNeList(V)) → MARK(U31(isQid(V)))
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
ACTIVE(isNePal(V)) → MARK(U61(isQid(V)))
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(U72(X)) → MARK(X)
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(154) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(isList(__(V1, V2))) → MARK(U21(isList(V1), V2))
ACTIVE(isNePal(V)) → MARK(U61(isQid(V)))
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
__(x1, x2)  =  __(x1, x2)
ACTIVE(x1)  =  ACTIVE(x1)
mark(x1)  =  x1
U11(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U22(x1)  =  x1
isList(x1)  =  isList(x1)
U31(x1)  =  x1
U41(x1, x2)  =  U41(x1, x2)
U42(x1)  =  U42(x1)
isNeList(x1)  =  isNeList(x1)
U51(x1, x2)  =  x1
isQid(x1)  =  isQid(x1)
U52(x1)  =  U52
U61(x1)  =  U61
U71(x1, x2)  =  U71
isNePal(x1)  =  isNePal
U72(x1)  =  x1
isPal(x1)  =  isPal
U81(x1)  =  U81
active(x1)  =  x1
nil  =  nil
tt  =  tt
a  =  a
e  =  e
i  =  i
o  =  o
u  =  u

Recursive path order with status [RPO].
Quasi-Precedence:
isNePal > [U71, isPal] > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > _2
isNePal > [U71, isPal] > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > [U212, isList1, U412, isNeList1, isQid1] > U421
a > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > _2
a > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > [U212, isList1, U412, isNeList1, isQid1] > U421
e > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > _2
e > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > [U212, isList1, U412, isNeList1, isQid1] > U421
i > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > _2
i > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > [U212, isList1, U412, isNeList1, isQid1] > U421
u > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > _2
u > [U52, U61, U81, nil, tt, o] > [MARK1, ACTIVE1] > [U212, isList1, U412, isNeList1, isQid1] > U421

Status:
MARK1: multiset
_2: [1,2]
ACTIVE1: multiset
U212: [2,1]
isList1: [1]
U412: [2,1]
U421: [1]
isNeList1: [1]
isQid1: [1]
U52: multiset
U61: multiset
U71: []
isNePal: []
isPal: []
U81: multiset
nil: multiset
tt: multiset
a: multiset
e: multiset
i: multiset
o: multiset
u: multiset


The following usable rules [FROCOS05] were oriented:

mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
mark(U11(X)) → active(U11(mark(X)))
active(__(X, nil)) → mark(X)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
active(__(nil, X)) → mark(X)
mark(U22(X)) → active(U22(mark(X)))
active(U21(tt, V2)) → mark(U22(isList(V2)))
mark(isList(X)) → active(isList(X))
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
mark(U31(X)) → active(U31(mark(X)))
active(U51(tt, V2)) → mark(U52(isList(V2)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
active(U71(tt, P)) → mark(U72(isPal(P)))
mark(U42(X)) → active(U42(mark(X)))
active(isList(V)) → mark(U11(isNeList(V)))
mark(isNeList(X)) → active(isNeList(X))
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
active(isNeList(V)) → mark(U31(isQid(V)))
mark(U52(X)) → active(U52(mark(X)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
mark(U61(X)) → active(U61(mark(X)))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
active(isNePal(V)) → mark(U61(isQid(V)))
mark(U72(X)) → active(U72(mark(X)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
mark(isPal(X)) → active(isPal(X))
active(isPal(V)) → mark(U81(isNePal(V)))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(nil) → active(nil)
mark(tt) → active(tt)
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(X1, mark(X2)) → __(X1, X2)
__(mark(X1), X2) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(active(X)) → U11(X)
U11(mark(X)) → U11(X)
U21(X1, mark(X2)) → U21(X1, X2)
U21(mark(X1), X2) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(active(X)) → U22(X)
U22(mark(X)) → U22(X)
isList(active(X)) → isList(X)
isList(mark(X)) → isList(X)
U31(active(X)) → U31(X)
U31(mark(X)) → U31(X)
U41(X1, mark(X2)) → U41(X1, X2)
U41(mark(X1), X2) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(active(X)) → U42(X)
U42(mark(X)) → U42(X)
isNeList(active(X)) → isNeList(X)
isNeList(mark(X)) → isNeList(X)
U51(X1, mark(X2)) → U51(X1, X2)
U51(mark(X1), X2) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
isQid(active(X)) → isQid(X)
isQid(mark(X)) → isQid(X)
U52(active(X)) → U52(X)
U52(mark(X)) → U52(X)
U61(active(X)) → U61(X)
U61(mark(X)) → U61(X)
U71(X1, mark(X2)) → U71(X1, X2)
U71(mark(X1), X2) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(active(X)) → U72(X)
U72(mark(X)) → U72(X)
isPal(active(X)) → isPal(X)
isPal(mark(X)) → isPal(X)
U81(active(X)) → U81(X)
U81(mark(X)) → U81(X)
isNePal(active(X)) → isNePal(X)
isNePal(mark(X)) → isNePal(X)
active(U11(tt)) → mark(tt)
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U42(tt)) → mark(tt)
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(nil)) → mark(tt)
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)

(155) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U11(X)) → MARK(X)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U31(X)) → MARK(X)
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U42(X)) → ACTIVE(U42(mark(X)))
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
MARK(isNeList(X)) → ACTIVE(isNeList(X))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
ACTIVE(isNeList(V)) → MARK(U31(isQid(V)))
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(U72(X)) → MARK(X)
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(156) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(isNeList(V)) → MARK(U31(isQid(V)))
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
__(x1, x2)  =  __(x1, x2)
ACTIVE(x1)  =  ACTIVE(x1)
mark(x1)  =  x1
U11(x1)  =  x1
U21(x1, x2)  =  U21
U22(x1)  =  x1
isList(x1)  =  isList
U31(x1)  =  x1
U41(x1, x2)  =  x1
U42(x1)  =  U42
isNeList(x1)  =  isNeList
U51(x1, x2)  =  U51
isQid(x1)  =  isQid
U52(x1)  =  x1
U61(x1)  =  U61
U71(x1, x2)  =  U71
U72(x1)  =  x1
isPal(x1)  =  isPal
U81(x1)  =  x1
isNePal(x1)  =  isNePal
active(x1)  =  x1
nil  =  nil
tt  =  tt
a  =  a
e  =  e
i  =  i
o  =  o
u  =  u

Recursive path order with status [RPO].
Quasi-Precedence:
[U21, isList, isNeList, U51] > [MARK1, ACTIVE1, isQid] > _2
[U21, isList, isNeList, U51] > [MARK1, ACTIVE1, isQid] > [U42, U61, U71, isPal, isNePal, tt]
a > [U42, U61, U71, isPal, isNePal, tt]
e > [U42, U61, U71, isPal, isNePal, tt]
i > [U42, U61, U71, isPal, isNePal, tt]
o > [U42, U61, U71, isPal, isNePal, tt]

Status:
MARK1: [1]
_2: [1,2]
ACTIVE1: [1]
U21: []
isList: []
U42: []
isNeList: []
U51: []
isQid: multiset
U61: []
U71: []
isPal: []
isNePal: []
nil: multiset
tt: multiset
a: multiset
e: multiset
i: multiset
o: multiset
u: multiset


The following usable rules [FROCOS05] were oriented:

mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
mark(U11(X)) → active(U11(mark(X)))
active(__(X, nil)) → mark(X)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
active(__(nil, X)) → mark(X)
mark(U22(X)) → active(U22(mark(X)))
active(U21(tt, V2)) → mark(U22(isList(V2)))
mark(isList(X)) → active(isList(X))
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
mark(U31(X)) → active(U31(mark(X)))
active(U51(tt, V2)) → mark(U52(isList(V2)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
active(U71(tt, P)) → mark(U72(isPal(P)))
mark(U42(X)) → active(U42(mark(X)))
active(isList(V)) → mark(U11(isNeList(V)))
mark(isNeList(X)) → active(isNeList(X))
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
active(isNeList(V)) → mark(U31(isQid(V)))
mark(U52(X)) → active(U52(mark(X)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
mark(U61(X)) → active(U61(mark(X)))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
active(isNePal(V)) → mark(U61(isQid(V)))
mark(U72(X)) → active(U72(mark(X)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
mark(isPal(X)) → active(isPal(X))
active(isPal(V)) → mark(U81(isNePal(V)))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(nil) → active(nil)
mark(tt) → active(tt)
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(X1, mark(X2)) → __(X1, X2)
__(mark(X1), X2) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(active(X)) → U11(X)
U11(mark(X)) → U11(X)
U21(X1, mark(X2)) → U21(X1, X2)
U21(mark(X1), X2) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(active(X)) → U22(X)
U22(mark(X)) → U22(X)
isList(active(X)) → isList(X)
isList(mark(X)) → isList(X)
U31(active(X)) → U31(X)
U31(mark(X)) → U31(X)
U41(X1, mark(X2)) → U41(X1, X2)
U41(mark(X1), X2) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(active(X)) → U42(X)
U42(mark(X)) → U42(X)
isNeList(active(X)) → isNeList(X)
isNeList(mark(X)) → isNeList(X)
U51(X1, mark(X2)) → U51(X1, X2)
U51(mark(X1), X2) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
isQid(active(X)) → isQid(X)
isQid(mark(X)) → isQid(X)
U52(active(X)) → U52(X)
U52(mark(X)) → U52(X)
U61(active(X)) → U61(X)
U61(mark(X)) → U61(X)
U71(X1, mark(X2)) → U71(X1, X2)
U71(mark(X1), X2) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(active(X)) → U72(X)
U72(mark(X)) → U72(X)
isPal(active(X)) → isPal(X)
isPal(mark(X)) → isPal(X)
U81(active(X)) → U81(X)
U81(mark(X)) → U81(X)
isNePal(active(X)) → isNePal(X)
isNePal(mark(X)) → isNePal(X)
active(U11(tt)) → mark(tt)
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U42(tt)) → mark(tt)
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(nil)) → mark(tt)
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)

(157) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U11(X)) → MARK(X)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U31(X)) → MARK(X)
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U42(X)) → ACTIVE(U42(mark(X)))
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
MARK(isNeList(X)) → ACTIVE(isNeList(X))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(U72(X)) → MARK(X)
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(158) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(U31(X)) → MARK(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
__(x1, x2)  =  __(x1, x2)
ACTIVE(x1)  =  ACTIVE(x1)
mark(x1)  =  x1
U11(x1)  =  x1
U21(x1, x2)  =  U21
U22(x1)  =  U22
isList(x1)  =  isList
U31(x1)  =  U31(x1)
U41(x1, x2)  =  U41
U42(x1)  =  U42
isNeList(x1)  =  isNeList
U51(x1, x2)  =  U51
U52(x1)  =  U52
U61(x1)  =  U61(x1)
U71(x1, x2)  =  x1
U72(x1)  =  x1
isPal(x1)  =  isPal
U81(x1)  =  U81
isQid(x1)  =  isQid
isNePal(x1)  =  isNePal(x1)
active(x1)  =  x1
nil  =  nil
tt  =  tt
a  =  a
e  =  e
i  =  i
o  =  o
u  =  u

Recursive path order with status [RPO].
Quasi-Precedence:
[MARK1, ACTIVE1, U21, U22, isList, U41, isNeList, U51] > _2 > [isQid, isNePal1] > [isPal, U81, tt] > U611
[MARK1, ACTIVE1, U21, U22, isList, U41, isNeList, U51] > U311 > [isPal, U81, tt] > U611
[MARK1, ACTIVE1, U21, U22, isList, U41, isNeList, U51] > U42 > [isPal, U81, tt] > U611
[MARK1, ACTIVE1, U21, U22, isList, U41, isNeList, U51] > U52 > [isPal, U81, tt] > U611
nil > [isPal, U81, tt] > U611
a > [isPal, U81, tt] > U611
e > U611
i > U611
o > U611
u > U611

Status:
MARK1: [1]
_2: [1,2]
ACTIVE1: [1]
U21: []
U22: []
isList: []
U311: [1]
U41: []
U42: multiset
isNeList: []
U51: []
U52: []
U611: [1]
isPal: multiset
U81: multiset
isQid: []
isNePal1: [1]
nil: multiset
tt: multiset
a: multiset
e: multiset
i: multiset
o: multiset
u: multiset


The following usable rules [FROCOS05] were oriented:

mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
mark(U11(X)) → active(U11(mark(X)))
active(__(X, nil)) → mark(X)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
active(__(nil, X)) → mark(X)
mark(U22(X)) → active(U22(mark(X)))
active(U21(tt, V2)) → mark(U22(isList(V2)))
mark(isList(X)) → active(isList(X))
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
mark(U31(X)) → active(U31(mark(X)))
active(U51(tt, V2)) → mark(U52(isList(V2)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
active(U71(tt, P)) → mark(U72(isPal(P)))
mark(U42(X)) → active(U42(mark(X)))
active(isList(V)) → mark(U11(isNeList(V)))
mark(isNeList(X)) → active(isNeList(X))
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
active(isNeList(V)) → mark(U31(isQid(V)))
mark(U52(X)) → active(U52(mark(X)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
mark(U61(X)) → active(U61(mark(X)))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
active(isNePal(V)) → mark(U61(isQid(V)))
mark(U72(X)) → active(U72(mark(X)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
mark(isPal(X)) → active(isPal(X))
active(isPal(V)) → mark(U81(isNePal(V)))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(nil) → active(nil)
mark(tt) → active(tt)
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(X1, mark(X2)) → __(X1, X2)
__(mark(X1), X2) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(active(X)) → U11(X)
U11(mark(X)) → U11(X)
U21(X1, mark(X2)) → U21(X1, X2)
U21(mark(X1), X2) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(active(X)) → U22(X)
U22(mark(X)) → U22(X)
isList(active(X)) → isList(X)
isList(mark(X)) → isList(X)
U31(active(X)) → U31(X)
U31(mark(X)) → U31(X)
U41(X1, mark(X2)) → U41(X1, X2)
U41(mark(X1), X2) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(active(X)) → U42(X)
U42(mark(X)) → U42(X)
isNeList(active(X)) → isNeList(X)
isNeList(mark(X)) → isNeList(X)
U51(X1, mark(X2)) → U51(X1, X2)
U51(mark(X1), X2) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(active(X)) → U52(X)
U52(mark(X)) → U52(X)
U61(active(X)) → U61(X)
U61(mark(X)) → U61(X)
U71(X1, mark(X2)) → U71(X1, X2)
U71(mark(X1), X2) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(active(X)) → U72(X)
U72(mark(X)) → U72(X)
isPal(active(X)) → isPal(X)
isPal(mark(X)) → isPal(X)
U81(active(X)) → U81(X)
U81(mark(X)) → U81(X)
isQid(active(X)) → isQid(X)
isQid(mark(X)) → isQid(X)
isNePal(active(X)) → isNePal(X)
isNePal(mark(X)) → isNePal(X)
active(U11(tt)) → mark(tt)
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U42(tt)) → mark(tt)
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(nil)) → mark(tt)
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)

(159) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U11(X)) → MARK(X)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U42(X)) → ACTIVE(U42(mark(X)))
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
MARK(isNeList(X)) → ACTIVE(isNeList(X))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(U72(X)) → MARK(X)
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(160) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(U72(X)) → MARK(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
__(x1, x2)  =  __(x1, x2)
ACTIVE(x1)  =  ACTIVE(x1)
mark(x1)  =  x1
U11(x1)  =  x1
U21(x1, x2)  =  x1
U22(x1)  =  U22
isList(x1)  =  isList(x1)
U31(x1)  =  U31
U41(x1, x2)  =  x1
U42(x1)  =  U42
isNeList(x1)  =  isNeList(x1)
U51(x1, x2)  =  U51(x1, x2)
U52(x1)  =  U52(x1)
U61(x1)  =  U61(x1)
U71(x1, x2)  =  U71(x1, x2)
U72(x1)  =  U72(x1)
isPal(x1)  =  isPal(x1)
U81(x1)  =  x1
isQid(x1)  =  x1
isNePal(x1)  =  isNePal(x1)
active(x1)  =  x1
nil  =  nil
tt  =  tt
a  =  a
e  =  e
i  =  i
o  =  o
u  =  u

Recursive path order with status [RPO].
Quasi-Precedence:
[2, U712] > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U521
[2, U712] > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U721
[2, U712] > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > [isPal1, isNePal1] > U611
[isList1, U31, isNeList1, U512] > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U521
[isList1, U31, isNeList1, U512] > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U721
[isList1, U31, isNeList1, U512] > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > [isPal1, isNePal1] > U611
nil > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U521
nil > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U721
nil > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > [isPal1, isNePal1] > U611
e > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U521
e > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U721
e > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > [isPal1, isNePal1] > U611
i > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U521
i > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > U721
i > [MARK1, ACTIVE1, U22, U42, tt, a, o, u] > [isPal1, isNePal1] > U611

Status:
MARK1: [1]
_2: [1,2]
ACTIVE1: [1]
U22: multiset
isList1: [1]
U31: []
U42: multiset
isNeList1: [1]
U512: [2,1]
U521: [1]
U611: [1]
U712: [2,1]
U721: [1]
isPal1: multiset
isNePal1: multiset
nil: multiset
tt: multiset
a: multiset
e: multiset
i: multiset
o: multiset
u: multiset


The following usable rules [FROCOS05] were oriented:

mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
mark(U11(X)) → active(U11(mark(X)))
active(__(X, nil)) → mark(X)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
active(__(nil, X)) → mark(X)
mark(U22(X)) → active(U22(mark(X)))
active(U21(tt, V2)) → mark(U22(isList(V2)))
mark(isList(X)) → active(isList(X))
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
mark(U31(X)) → active(U31(mark(X)))
active(U51(tt, V2)) → mark(U52(isList(V2)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
active(U71(tt, P)) → mark(U72(isPal(P)))
mark(U42(X)) → active(U42(mark(X)))
active(isList(V)) → mark(U11(isNeList(V)))
mark(isNeList(X)) → active(isNeList(X))
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
active(isNeList(V)) → mark(U31(isQid(V)))
mark(U52(X)) → active(U52(mark(X)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
mark(U61(X)) → active(U61(mark(X)))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
active(isNePal(V)) → mark(U61(isQid(V)))
mark(U72(X)) → active(U72(mark(X)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
mark(isPal(X)) → active(isPal(X))
active(isPal(V)) → mark(U81(isNePal(V)))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(nil) → active(nil)
mark(tt) → active(tt)
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(X1, mark(X2)) → __(X1, X2)
__(mark(X1), X2) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(active(X)) → U11(X)
U11(mark(X)) → U11(X)
U21(X1, mark(X2)) → U21(X1, X2)
U21(mark(X1), X2) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(active(X)) → U22(X)
U22(mark(X)) → U22(X)
isList(active(X)) → isList(X)
isList(mark(X)) → isList(X)
U31(active(X)) → U31(X)
U31(mark(X)) → U31(X)
U41(X1, mark(X2)) → U41(X1, X2)
U41(mark(X1), X2) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(active(X)) → U42(X)
U42(mark(X)) → U42(X)
isNeList(active(X)) → isNeList(X)
isNeList(mark(X)) → isNeList(X)
U51(X1, mark(X2)) → U51(X1, X2)
U51(mark(X1), X2) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(active(X)) → U52(X)
U52(mark(X)) → U52(X)
U61(active(X)) → U61(X)
U61(mark(X)) → U61(X)
U71(X1, mark(X2)) → U71(X1, X2)
U71(mark(X1), X2) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(active(X)) → U72(X)
U72(mark(X)) → U72(X)
isPal(active(X)) → isPal(X)
isPal(mark(X)) → isPal(X)
U81(active(X)) → U81(X)
U81(mark(X)) → U81(X)
isQid(active(X)) → isQid(X)
isQid(mark(X)) → isQid(X)
isNePal(active(X)) → isNePal(X)
isNePal(mark(X)) → isNePal(X)
active(U11(tt)) → mark(tt)
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U42(tt)) → mark(tt)
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(nil)) → mark(tt)
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)

(161) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U11(X)) → MARK(X)
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U42(X)) → ACTIVE(U42(mark(X)))
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
MARK(isNeList(X)) → ACTIVE(isNeList(X))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(162) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(U11(X)) → MARK(X)
ACTIVE(isList(V)) → MARK(U11(isNeList(V)))
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
__(x1, x2)  =  __(x1, x2)
ACTIVE(x1)  =  ACTIVE(x1)
mark(x1)  =  x1
U11(x1)  =  U11(x1)
U21(x1, x2)  =  x1
U22(x1)  =  U22
isList(x1)  =  isList
U31(x1)  =  x1
U41(x1, x2)  =  U41
U42(x1)  =  U42
isNeList(x1)  =  isNeList
U51(x1, x2)  =  U51
U52(x1)  =  U52
U61(x1)  =  U61
U71(x1, x2)  =  x1
U72(x1)  =  U72
isPal(x1)  =  isPal(x1)
U81(x1)  =  x1
isQid(x1)  =  isQid
isNePal(x1)  =  isNePal(x1)
active(x1)  =  x1
nil  =  nil
tt  =  tt
a  =  a
e  =  e
i  =  i
o  =  o
u  =  u

Recursive path order with status [RPO].
Quasi-Precedence:
[2, isList] > U111 > [MARK1, ACTIVE1] > U52 > [U22, U72, nil, tt, a, e, u]
[2, isList] > [U41, U42, isNeList, U51, isQid] > [MARK1, ACTIVE1] > U52 > [U22, U72, nil, tt, a, e, u]
isPal1 > isNePal1 > [U41, U42, isNeList, U51, isQid] > [MARK1, ACTIVE1] > U52 > [U22, U72, nil, tt, a, e, u]
isPal1 > isNePal1 > U61 > [MARK1, ACTIVE1] > U52 > [U22, U72, nil, tt, a, e, u]
i > [U22, U72, nil, tt, a, e, u]
o > [U22, U72, nil, tt, a, e, u]

Status:
MARK1: [1]
_2: [1,2]
ACTIVE1: [1]
U111: multiset
U22: multiset
isList: multiset
U41: []
U42: []
isNeList: []
U51: []
U52: multiset
U61: multiset
U72: multiset
isPal1: [1]
isQid: []
isNePal1: multiset
nil: multiset
tt: multiset
a: multiset
e: multiset
i: multiset
o: multiset
u: multiset


The following usable rules [FROCOS05] were oriented:

mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
active(__(__(X, Y), Z)) → mark(__(X, __(Y, Z)))
mark(U11(X)) → active(U11(mark(X)))
active(__(X, nil)) → mark(X)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
active(__(nil, X)) → mark(X)
mark(U22(X)) → active(U22(mark(X)))
active(U21(tt, V2)) → mark(U22(isList(V2)))
mark(isList(X)) → active(isList(X))
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
mark(U31(X)) → active(U31(mark(X)))
active(U51(tt, V2)) → mark(U52(isList(V2)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
active(U71(tt, P)) → mark(U72(isPal(P)))
mark(U42(X)) → active(U42(mark(X)))
active(isList(V)) → mark(U11(isNeList(V)))
mark(isNeList(X)) → active(isNeList(X))
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
active(isNeList(V)) → mark(U31(isQid(V)))
mark(U52(X)) → active(U52(mark(X)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
mark(U61(X)) → active(U61(mark(X)))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
active(isNePal(V)) → mark(U61(isQid(V)))
mark(U72(X)) → active(U72(mark(X)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
mark(isPal(X)) → active(isPal(X))
active(isPal(V)) → mark(U81(isNePal(V)))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(nil) → active(nil)
mark(tt) → active(tt)
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(X1, mark(X2)) → __(X1, X2)
__(mark(X1), X2) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(active(X)) → U11(X)
U11(mark(X)) → U11(X)
U21(X1, mark(X2)) → U21(X1, X2)
U21(mark(X1), X2) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(active(X)) → U22(X)
U22(mark(X)) → U22(X)
isList(active(X)) → isList(X)
isList(mark(X)) → isList(X)
U31(active(X)) → U31(X)
U31(mark(X)) → U31(X)
U41(X1, mark(X2)) → U41(X1, X2)
U41(mark(X1), X2) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(active(X)) → U42(X)
U42(mark(X)) → U42(X)
isNeList(active(X)) → isNeList(X)
isNeList(mark(X)) → isNeList(X)
U51(X1, mark(X2)) → U51(X1, X2)
U51(mark(X1), X2) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(active(X)) → U52(X)
U52(mark(X)) → U52(X)
U61(active(X)) → U61(X)
U61(mark(X)) → U61(X)
U71(X1, mark(X2)) → U71(X1, X2)
U71(mark(X1), X2) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(active(X)) → U72(X)
U72(mark(X)) → U72(X)
isPal(active(X)) → isPal(X)
isPal(mark(X)) → isPal(X)
U81(active(X)) → U81(X)
U81(mark(X)) → U81(X)
isQid(active(X)) → isQid(X)
isQid(mark(X)) → isQid(X)
isNePal(active(X)) → isNePal(X)
isNePal(mark(X)) → isNePal(X)
active(U11(tt)) → mark(tt)
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U42(tt)) → mark(tt)
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(nil)) → mark(tt)
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)

(163) Obligation:

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

MARK(__(X1, X2)) → ACTIVE(__(mark(X1), mark(X2)))
MARK(U11(X)) → ACTIVE(U11(mark(X)))
MARK(U21(X1, X2)) → ACTIVE(U21(mark(X1), X2))
MARK(U22(X)) → ACTIVE(U22(mark(X)))
MARK(isList(X)) → ACTIVE(isList(X))
MARK(U31(X)) → ACTIVE(U31(mark(X)))
MARK(U41(X1, X2)) → ACTIVE(U41(mark(X1), X2))
MARK(U42(X)) → ACTIVE(U42(mark(X)))
MARK(isNeList(X)) → ACTIVE(isNeList(X))
MARK(U51(X1, X2)) → ACTIVE(U51(mark(X1), X2))
MARK(U52(X)) → ACTIVE(U52(mark(X)))
MARK(U61(X)) → ACTIVE(U61(mark(X)))
MARK(U71(X1, X2)) → ACTIVE(U71(mark(X1), X2))
MARK(U72(X)) → ACTIVE(U72(mark(X)))
MARK(isPal(X)) → ACTIVE(isPal(X))
MARK(U81(X)) → ACTIVE(U81(mark(X)))
MARK(isQid(X)) → ACTIVE(isQid(X))
MARK(isNePal(X)) → ACTIVE(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(tt)
active(U21(tt, V2)) → mark(U22(isList(V2)))
active(U22(tt)) → mark(tt)
active(U31(tt)) → mark(tt)
active(U41(tt, V2)) → mark(U42(isNeList(V2)))
active(U42(tt)) → mark(tt)
active(U51(tt, V2)) → mark(U52(isList(V2)))
active(U52(tt)) → mark(tt)
active(U61(tt)) → mark(tt)
active(U71(tt, P)) → mark(U72(isPal(P)))
active(U72(tt)) → mark(tt)
active(U81(tt)) → mark(tt)
active(isList(V)) → mark(U11(isNeList(V)))
active(isList(nil)) → mark(tt)
active(isList(__(V1, V2))) → mark(U21(isList(V1), V2))
active(isNeList(V)) → mark(U31(isQid(V)))
active(isNeList(__(V1, V2))) → mark(U41(isList(V1), V2))
active(isNeList(__(V1, V2))) → mark(U51(isNeList(V1), V2))
active(isNePal(V)) → mark(U61(isQid(V)))
active(isNePal(__(I, __(P, I)))) → mark(U71(isQid(I), P))
active(isPal(V)) → mark(U81(isNePal(V)))
active(isPal(nil)) → mark(tt)
active(isQid(a)) → mark(tt)
active(isQid(e)) → mark(tt)
active(isQid(i)) → mark(tt)
active(isQid(o)) → mark(tt)
active(isQid(u)) → mark(tt)
mark(__(X1, X2)) → active(__(mark(X1), mark(X2)))
mark(nil) → active(nil)
mark(U11(X)) → active(U11(mark(X)))
mark(tt) → active(tt)
mark(U21(X1, X2)) → active(U21(mark(X1), X2))
mark(U22(X)) → active(U22(mark(X)))
mark(isList(X)) → active(isList(X))
mark(U31(X)) → active(U31(mark(X)))
mark(U41(X1, X2)) → active(U41(mark(X1), X2))
mark(U42(X)) → active(U42(mark(X)))
mark(isNeList(X)) → active(isNeList(X))
mark(U51(X1, X2)) → active(U51(mark(X1), X2))
mark(U52(X)) → active(U52(mark(X)))
mark(U61(X)) → active(U61(mark(X)))
mark(U71(X1, X2)) → active(U71(mark(X1), X2))
mark(U72(X)) → active(U72(mark(X)))
mark(isPal(X)) → active(isPal(X))
mark(U81(X)) → active(U81(mark(X)))
mark(isQid(X)) → active(isQid(X))
mark(isNePal(X)) → active(isNePal(X))
mark(a) → active(a)
mark(e) → active(e)
mark(i) → active(i)
mark(o) → active(o)
mark(u) → active(u)
__(mark(X1), X2) → __(X1, X2)
__(X1, mark(X2)) → __(X1, X2)
__(active(X1), X2) → __(X1, X2)
__(X1, active(X2)) → __(X1, X2)
U11(mark(X)) → U11(X)
U11(active(X)) → U11(X)
U21(mark(X1), X2) → U21(X1, X2)
U21(X1, mark(X2)) → U21(X1, X2)
U21(active(X1), X2) → U21(X1, X2)
U21(X1, active(X2)) → U21(X1, X2)
U22(mark(X)) → U22(X)
U22(active(X)) → U22(X)
isList(mark(X)) → isList(X)
isList(active(X)) → isList(X)
U31(mark(X)) → U31(X)
U31(active(X)) → U31(X)
U41(mark(X1), X2) → U41(X1, X2)
U41(X1, mark(X2)) → U41(X1, X2)
U41(active(X1), X2) → U41(X1, X2)
U41(X1, active(X2)) → U41(X1, X2)
U42(mark(X)) → U42(X)
U42(active(X)) → U42(X)
isNeList(mark(X)) → isNeList(X)
isNeList(active(X)) → isNeList(X)
U51(mark(X1), X2) → U51(X1, X2)
U51(X1, mark(X2)) → U51(X1, X2)
U51(active(X1), X2) → U51(X1, X2)
U51(X1, active(X2)) → U51(X1, X2)
U52(mark(X)) → U52(X)
U52(active(X)) → U52(X)
U61(mark(X)) → U61(X)
U61(active(X)) → U61(X)
U71(mark(X1), X2) → U71(X1, X2)
U71(X1, mark(X2)) → U71(X1, X2)
U71(active(X1), X2) → U71(X1, X2)
U71(X1, active(X2)) → U71(X1, X2)
U72(mark(X)) → U72(X)
U72(active(X)) → U72(X)
isPal(mark(X)) → isPal(X)
isPal(active(X)) → isPal(X)
U81(mark(X)) → U81(X)
U81(active(X)) → U81(X)
isQid(mark(X)) → isQid(X)
isQid(active(X)) → isQid(X)
isNePal(mark(X)) → isNePal(X)
isNePal(active(X)) → isNePal(X)

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

(164) DependencyGraphProof (EQUIVALENT transformation)

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

(165) TRUE