/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Problem 1: 

(VAR I P V V1 V2 X X1 X2 Y Z)
(RULES
__(__(X,Y),Z) -> __(X,__(Y,Z))
__(nil,X) -> X
__(X,nil) -> X
__(X1,X2) -> n____(X1,X2)
a -> n__a
activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
activate(n__a) -> a
activate(n__e) -> e
activate(n__i) -> i
activate(n__isList(X)) -> isList(X)
activate(n__isNeList(X)) -> isNeList(X)
activate(n__isPal(X)) -> isPal(X)
activate(n__nil) -> nil
activate(n__o) -> o
activate(n__u) -> u
activate(X) -> X
and(tt,X) -> activate(X)
e -> n__e
i -> n__i
isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
isList(n__nil) -> tt
isList(V) -> isNeList(activate(V))
isList(X) -> n__isList(X)
isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
isNeList(V) -> isQid(activate(V))
isNeList(X) -> n__isNeList(X)
isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
isNePal(V) -> isQid(activate(V))
isPal(n__nil) -> tt
isPal(V) -> isNePal(activate(V))
isPal(X) -> n__isPal(X)
isQid(n__a) -> tt
isQid(n__e) -> tt
isQid(n__i) -> tt
isQid(n__o) -> tt
isQid(n__u) -> tt
nil -> n__nil
o -> n__o
u -> n__u
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 __#(__(X,Y),Z) -> __#(X,__(Y,Z))
 __#(__(X,Y),Z) -> __#(Y,Z)
 ACTIVATE(n____(X1,X2)) -> __#(activate(X1),activate(X2))
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X1)
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__a) -> A
 ACTIVATE(n__e) -> E
 ACTIVATE(n__i) -> I
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 ACTIVATE(n__nil) -> NIL
 ACTIVATE(n__o) -> O
 ACTIVATE(n__u) -> U
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNELIST(V) -> ISQID(activate(V))
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(n____(I,n____(P,I))) -> ISQID(activate(I))
 ISNEPAL(V) -> ACTIVATE(V)
 ISNEPAL(V) -> ISQID(activate(V))
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u

Problem 1: 

SCC Processor:
-> Pairs:
 __#(__(X,Y),Z) -> __#(X,__(Y,Z))
 __#(__(X,Y),Z) -> __#(Y,Z)
 ACTIVATE(n____(X1,X2)) -> __#(activate(X1),activate(X2))
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X1)
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__a) -> A
 ACTIVATE(n__e) -> E
 ACTIVATE(n__i) -> I
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 ACTIVATE(n__nil) -> NIL
 ACTIVATE(n__o) -> O
 ACTIVATE(n__u) -> U
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNELIST(V) -> ISQID(activate(V))
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(n____(I,n____(P,I))) -> ISQID(activate(I))
 ISNEPAL(V) -> ACTIVATE(V)
 ISNEPAL(V) -> ISQID(activate(V))
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 __#(__(X,Y),Z) -> __#(X,__(Y,Z))
 __#(__(X,Y),Z) -> __#(Y,Z)
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->->Cycle:
->->-> Pairs:
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X1)
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u


The problem is decomposed in 2 subproblems.

Problem 1.1: 

Subterm Processor:
-> Pairs:
 __#(__(X,Y),Z) -> __#(X,__(Y,Z))
 __#(__(X,Y),Z) -> __#(Y,Z)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Projection:
 pi(__#) = 1

Problem 1.1: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X1)
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 0
[activate](X) = X
[and](X1,X2) = X1 + X2 + 2
[e] = 1
[i] = 1
[isList](X) = 2.X + 2
[isNeList](X) = 2.X + 2
[isNePal](X) = X + 2
[isPal](X) = 2.X + 2
[isQid](X) = 2
[nil] = 1
[o] = 2
[u] = 2
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 0
[n__e] = 1
[n__i] = 1
[n__isList](X) = 2.X + 2
[n__isNeList](X) = 2.X + 2
[n__isPal](X) = 2.X + 2
[n__nil] = 1
[n__o] = 2
[n__u] = 2
[tt] = 2
[ACTIVATE](X) = X + 2
[AND](X1,X2) = X1 + X2 + 2
[ISLIST](X) = 2.X + 2
[ISNELIST](X) = 2.X + 2
[ISNEPAL](X) = 2.X + 2
[ISPAL](X) = 2.X + 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u

Problem 1.2: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n____(X1,X2)) -> ACTIVATE(X2)
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 2
[activate](X) = X
[and](X1,X2) = 2.X1 + X2
[e] = 1
[i] = 1
[isList](X) = X + 1
[isNeList](X) = X + 1
[isNePal](X) = X + 1
[isPal](X) = 2.X + 1
[isQid](X) = X + 1
[nil] = 2
[o] = 2
[u] = 2
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 2
[n__e] = 1
[n__i] = 1
[n__isList](X) = X + 1
[n__isNeList](X) = X + 1
[n__isPal](X) = 2.X + 1
[n__nil] = 2
[n__o] = 2
[n__u] = 2
[tt] = 2
[ACTIVATE](X) = 2.X + 2
[AND](X1,X2) = 2.X1 + 2.X2 + 2
[ISLIST](X) = 2.X + 2
[ISNELIST](X) = 2.X + 2
[ISNEPAL](X) = 2.X + 2
[ISPAL](X) = 2.X + 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u

Problem 1.2: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n__isList(X)) -> ISLIST(X)
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 2
[activate](X) = X
[and](X1,X2) = 2.X1 + X2
[e] = 2
[i] = 2
[isList](X) = 2.X + 2
[isNeList](X) = 2.X + 2
[isNePal](X) = 2.X + 2
[isPal](X) = 2.X + 2
[isQid](X) = 2.X + 2
[nil] = 2
[o] = 2
[u] = 1
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 2
[n__e] = 2
[n__i] = 2
[n__isList](X) = 2.X + 2
[n__isNeList](X) = 2.X + 2
[n__isPal](X) = 2.X + 2
[n__nil] = 2
[n__o] = 2
[n__u] = 1
[tt] = 2
[ACTIVATE](X) = X + 1
[AND](X1,X2) = X2 + 2
[ISLIST](X) = 2.X + 2
[ISNELIST](X) = 2.X + 2
[ISNEPAL](X) = 2.X + 1
[ISPAL](X) = 2.X + 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u

Problem 1.2: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n__isNeList(X)) -> ISNELIST(X)
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 2
[activate](X) = X
[and](X1,X2) = 2.X1 + X2
[e] = 2
[i] = 2
[isList](X) = X + 1
[isNeList](X) = X + 1
[isNePal](X) = 2.X + 1
[isPal](X) = 2.X + 1
[isQid](X) = X + 1
[nil] = 2
[o] = 2
[u] = 1
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 2
[n__e] = 2
[n__i] = 2
[n__isList](X) = X + 1
[n__isNeList](X) = X + 1
[n__isPal](X) = 2.X + 1
[n__nil] = 2
[n__o] = 2
[n__u] = 1
[tt] = 2
[ACTIVATE](X) = 2.X + 2
[AND](X1,X2) = 2.X1 + 2.X2 + 2
[ISLIST](X) = 2.X + 2
[ISNELIST](X) = 2.X + 2
[ISNEPAL](X) = 2.X + 2
[ISPAL](X) = 2.X + 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISLIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISLIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isList(activate(V2)))
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ACTIVATE(V)
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V1)
 ISNELIST(n____(V1,V2)) -> ACTIVATE(V2)
 ISNELIST(n____(V1,V2)) -> AND(isList(activate(V1)),n__isNeList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> AND(isNeList(activate(V1)),n__isList(activate(V2)))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
 ISNELIST(V) -> ACTIVATE(V)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->->Cycle:
->->-> Pairs:
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u


The problem is decomposed in 2 subproblems.

Problem 1.2.1: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n__isPal(X)) -> ISPAL(X)
 AND(tt,X) -> ACTIVATE(X)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 2
[activate](X) = X
[and](X1,X2) = X2
[e] = 1
[i] = 1
[isList](X) = 2.X + 2
[isNeList](X) = 2.X + 2
[isNePal](X) = 2.X + 2
[isPal](X) = 2.X + 2
[isQid](X) = 2
[nil] = 0
[o] = 2
[u] = 2
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 2
[n__e] = 1
[n__i] = 1
[n__isList](X) = 2.X + 2
[n__isNeList](X) = 2.X + 2
[n__isPal](X) = 2.X + 2
[n__nil] = 0
[n__o] = 2
[n__u] = 2
[tt] = 2
[ACTIVATE](X) = 2.X + 1
[AND](X1,X2) = 2.X1 + 2.X2
[ISNEPAL](X) = 2.X + 2
[ISPAL](X) = 2.X + 2

Problem 1.2.1: 

SCC Processor:
-> Pairs:
 AND(tt,X) -> ACTIVATE(X)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(I)
 ISNEPAL(n____(I,n____(P,I))) -> ACTIVATE(P)
 ISNEPAL(n____(I,n____(P,I))) -> AND(isQid(activate(I)),n__isPal(activate(P)))
 ISNEPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ACTIVATE(V)
 ISPAL(V) -> ISNEPAL(activate(V))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2.2: 

Reduction Pair Processor:
-> Pairs:
 ISLIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = X1 + X2 + 2
[a] = 2
[activate](X) = X
[and](X1,X2) = X2 + 1
[e] = 2
[i] = 1
[isList](X) = 2.X + 2
[isNeList](X) = 2.X
[isNePal](X) = 2.X + 2
[isPal](X) = 2.X + 2
[isQid](X) = 2.X
[nil] = 2
[o] = 1
[u] = 2
[n____](X1,X2) = X1 + X2 + 2
[n__a] = 2
[n__e] = 2
[n__i] = 1
[n__isList](X) = 2.X + 2
[n__isNeList](X) = 2.X
[n__isPal](X) = 2.X + 2
[n__nil] = 2
[n__o] = 1
[n__u] = 2
[tt] = 2
[ISLIST](X) = 2.X + 1
[ISNELIST](X) = 2.X + 1

Problem 1.2.2: 

SCC Processor:
-> Pairs:
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u

Problem 1.2.2: 

Reduction Pair Processor:
-> Pairs:
 ISLIST(V) -> ISNELIST(activate(V))
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 1
[activate](X) = X
[and](X1,X2) = 2.X1 + X2 + 2
[e] = 2
[i] = 2
[isList](X) = 2.X + 1
[isNeList](X) = 2.X + 1
[isNePal](X) = 2.X + 2
[isPal](X) = 2.X + 2
[isQid](X) = 2.X + 1
[nil] = 2
[o] = 2
[u] = 2
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 1
[n__e] = 2
[n__i] = 2
[n__isList](X) = 2.X + 1
[n__isNeList](X) = 2.X + 1
[n__isPal](X) = 2.X + 2
[n__nil] = 2
[n__o] = 2
[n__u] = 2
[tt] = 0
[ISLIST](X) = 2.X + 2
[ISNELIST](X) = 2.X + 1

Problem 1.2.2: 

SCC Processor:
-> Pairs:
 ISNELIST(n____(V1,V2)) -> ISLIST(activate(V1))
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u

Problem 1.2.2: 

Reduction Pair Processor:
-> Pairs:
 ISNELIST(n____(V1,V2)) -> ISNELIST(activate(V1))
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 2
[a] = 2
[activate](X) = 2.X + 1
[and](X1,X2) = 2.X2 + 1
[e] = 0
[i] = 2
[isList](X) = 1
[isNeList](X) = 1
[isNePal](X) = 1
[isPal](X) = 1
[isQid](X) = 1
[nil] = 2
[o] = 0
[u] = 2
[n____](X1,X2) = 2.X1 + X2 + 2
[n__a] = 1
[n__e] = 0
[n__i] = 2
[n__isList](X) = 0
[n__isNeList](X) = 0
[n__isPal](X) = 0
[n__nil] = 1
[n__o] = 0
[n__u] = 1
[tt] = 0
[ISNELIST](X) = X

Problem 1.2.2: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 __(X1,X2) -> n____(X1,X2)
 a -> n__a
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__a) -> a
 activate(n__e) -> e
 activate(n__i) -> i
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__nil) -> nil
 activate(n__o) -> o
 activate(n__u) -> u
 activate(X) -> X
 and(tt,X) -> activate(X)
 e -> n__e
 i -> n__i
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isList(n__nil) -> tt
 isList(V) -> isNeList(activate(V))
 isList(X) -> n__isList(X)
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(X) -> n__isNeList(X)
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isNePal(V) -> isQid(activate(V))
 isPal(n__nil) -> tt
 isPal(V) -> isNePal(activate(V))
 isPal(X) -> n__isPal(X)
 isQid(n__a) -> tt
 isQid(n__e) -> tt
 isQid(n__i) -> tt
 isQid(n__o) -> tt
 isQid(n__u) -> tt
 nil -> n__nil
 o -> n__o
 u -> n__u
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.