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


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


YES

Problem 1: 

(VAR I P V V1 V2 X Y Z)
(STRATEGY CONTEXTSENSITIVE
(__ 1 2)
(and 1)
(isList)
(isNeList)
(isNePal)
(isPal)
(isQid)
(a)
(e)
(i)
(nil)
(o)
(tt)
(u)
)
(RULES
__(__(X,Y),Z) -> __(X,__(Y,Z))
__(nil,X) -> X
__(X,nil) -> X
and(tt,X) -> X
isList(__(V1,V2)) -> and(isList(V1),isList(V2))
isList(nil) -> tt
isList(V) -> isNeList(V)
isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
isNeList(V) -> isQid(V)
isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
isNePal(V) -> isQid(V)
isPal(nil) -> tt
isPal(V) -> isNePal(V)
isQid(a) -> tt
isQid(e) -> tt
isQid(i) -> tt
isQid(o) -> tt
isQid(u) -> tt
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 __#(__(X,Y),Z) -> __#(X,__(Y,Z))
 __#(__(X,Y),Z) -> __#(Y,Z)
 AND(tt,X) -> X
 ISLIST(__(V1,V2)) -> AND(isList(V1),isList(V2))
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> AND(isList(V1),isNeList(V2))
 ISNELIST(__(V1,V2)) -> AND(isNeList(V1),isList(V2))
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
 ISNELIST(V) -> ISQID(V)
 ISNEPAL(__(I,__(P,I))) -> AND(isQid(I),isPal(P))
 ISNEPAL(__(I,__(P,I))) -> ISQID(I)
 ISNEPAL(V) -> ISQID(V)
 ISPAL(V) -> ISNEPAL(V)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding Rules:
 isList(V2) -> ISLIST(V2)
 isNeList(V2) -> ISNELIST(V2)
 isPal(P) -> ISPAL(P)

Problem 1: 

SCC Processor:
-> Pairs:
 __#(__(X,Y),Z) -> __#(X,__(Y,Z))
 __#(__(X,Y),Z) -> __#(Y,Z)
 AND(tt,X) -> X
 ISLIST(__(V1,V2)) -> AND(isList(V1),isList(V2))
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> AND(isList(V1),isNeList(V2))
 ISNELIST(__(V1,V2)) -> AND(isNeList(V1),isList(V2))
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
 ISNELIST(V) -> ISQID(V)
 ISNEPAL(__(I,__(P,I))) -> AND(isQid(I),isPal(P))
 ISNEPAL(__(I,__(P,I))) -> ISQID(I)
 ISNEPAL(V) -> ISQID(V)
 ISPAL(V) -> ISNEPAL(V)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 isList(V2) -> ISLIST(V2)
 isNeList(V2) -> ISNELIST(V2)
 isPal(P) -> ISPAL(P)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 AND(tt,X) -> X
 ISLIST(__(V1,V2)) -> AND(isList(V1),isList(V2))
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> AND(isList(V1),isNeList(V2))
 ISNELIST(__(V1,V2)) -> AND(isNeList(V1),isList(V2))
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
 ISNEPAL(__(I,__(P,I))) -> AND(isQid(I),isPal(P))
 ISPAL(V) -> ISNEPAL(V)
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
->->-> Unhiding rules:
 isList(V2) -> ISLIST(V2)
 isNeList(V2) -> ISNELIST(V2)
 isPal(P) -> ISPAL(P)
->->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
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
->->-> Unhiding rules:
 Empty


The problem is decomposed in 2 subproblems.

Problem 1.1: 

Reduction Pairs Processor:
-> Pairs:
 AND(tt,X) -> X
 ISLIST(__(V1,V2)) -> AND(isList(V1),isList(V2))
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> AND(isList(V1),isNeList(V2))
 ISNELIST(__(V1,V2)) -> AND(isNeList(V1),isList(V2))
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
 ISNEPAL(__(I,__(P,I))) -> AND(isQid(I),isPal(P))
 ISPAL(V) -> ISNEPAL(V)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 isList(V2) -> ISLIST(V2)
 isNeList(V2) -> ISNELIST(V2)
 isPal(P) -> ISPAL(P)
-> Usable rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[__](X1,X2) = 2.X1 + X2 + 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
[isQid](X) = 2.X + 2
[a] = 2
[e] = 2
[i] = 2
[nil] = 2
[o] = 2
[tt] = 0
[u] = 0
[AND](X1,X2) = X2 + 1
[ISLIST](X) = 2.X + 2
[ISNELIST](X) = 2.X + 2
[ISNEPAL](X) = 2.X + 2
[ISPAL](X) = 2.X + 2

Problem 1.1: 

SCC Processor:
-> Pairs:
 ISLIST(__(V1,V2)) -> AND(isList(V1),isList(V2))
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> AND(isList(V1),isNeList(V2))
 ISNELIST(__(V1,V2)) -> AND(isNeList(V1),isList(V2))
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
 ISNEPAL(__(I,__(P,I))) -> AND(isQid(I),isPal(P))
 ISPAL(V) -> ISNEPAL(V)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 isList(V2) -> ISLIST(V2)
 isNeList(V2) -> ISNELIST(V2)
 isPal(P) -> ISPAL(P)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
->->-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
->->-> Unhiding rules:
 Empty

Problem 1.1: 

SubNColl Processor:
-> Pairs:
 ISLIST(__(V1,V2)) -> ISLIST(V1)
 ISLIST(V) -> ISNELIST(V)
 ISNELIST(__(V1,V2)) -> ISLIST(V1)
 ISNELIST(__(V1,V2)) -> ISNELIST(V1)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 Empty
->Projection:
 pi(ISLIST) = 1
 pi(ISNELIST) = 1

Problem 1.1: 

SCC Processor:
-> Pairs:
 ISLIST(V) -> ISNELIST(V)
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 Empty
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

SubNColl 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
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 Empty
->Projection:
 pi(__#) = 1

Problem 1.2: 

Basic Processor:
-> Pairs:
 Empty
-> Rules:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(nil,X) -> X
 __(X,nil) -> X
 and(tt,X) -> X
 isList(__(V1,V2)) -> and(isList(V1),isList(V2))
 isList(nil) -> tt
 isList(V) -> isNeList(V)
 isNeList(__(V1,V2)) -> and(isList(V1),isNeList(V2))
 isNeList(__(V1,V2)) -> and(isNeList(V1),isList(V2))
 isNeList(V) -> isQid(V)
 isNePal(__(I,__(P,I))) -> and(isQid(I),isPal(P))
 isNePal(V) -> isQid(V)
 isPal(nil) -> tt
 isPal(V) -> isNePal(V)
 isQid(a) -> tt
 isQid(e) -> tt
 isQid(i) -> tt
 isQid(o) -> tt
 isQid(u) -> tt
-> Unhiding rules:
 Empty
-> Result:
 Set P is empty

The problem is finite.