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


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


YES

Problem 1: 

(VAR v_NonEmpty:S assign:S clause:S cnf:S e:S l:S ls:S t:S x:S xs:S y:S ys:S)
(RULES
choice(cons(x:S,xs:S)) -> choice(xs:S)
choice(cons(x:S,xs:S)) -> x:S
eq(0(x:S),1(y:S)) -> ffalse
eq(1(x:S),0(y:S)) -> ffalse
eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
eq(nil,nil) -> ttrue
guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
guess(nil) -> nil
if(ffalse,t:S,e:S) -> e:S
if(ttrue,t:S,e:S) -> t:S
member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
member(x:S,nil) -> ffalse
negate(0(x:S)) -> 1(x:S)
negate(1(x:S)) -> 0(x:S)
sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
verify(nil) -> ttrue
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 CHOICE(cons(x:S,xs:S)) -> CHOICE(xs:S)
 EQ(1(x:S),1(y:S)) -> EQ(x:S,y:S)
 EQ(O(x:S),0(y:S)) -> EQ(x:S,y:S)
 GUESS(cons(clause:S,cnf:S)) -> CHOICE(clause:S)
 GUESS(cons(clause:S,cnf:S)) -> GUESS(cnf:S)
 MEMBER(x:S,cons(y:S,ys:S)) -> EQ(x:S,y:S)
 MEMBER(x:S,cons(y:S,ys:S)) -> IF(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 MEMBER(x:S,cons(y:S,ys:S)) -> MEMBER(x:S,ys:S)
 SAT(cnf:S) -> GUESS(cnf:S)
 SAT(cnf:S) -> SATCK(cnf:S,guess(cnf:S))
 SATCK(cnf:S,assign:S) -> IF(verify(assign:S),assign:S,unsat)
 SATCK(cnf:S,assign:S) -> VERIFY(assign:S)
 VERIFY(cons(l:S,ls:S)) -> IF(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 VERIFY(cons(l:S,ls:S)) -> MEMBER(negate(l:S),ls:S)
 VERIFY(cons(l:S,ls:S)) -> NEGATE(l:S)
 VERIFY(cons(l:S,ls:S)) -> VERIFY(ls:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue

Problem 1: 

SCC Processor:
-> Pairs:
 CHOICE(cons(x:S,xs:S)) -> CHOICE(xs:S)
 EQ(1(x:S),1(y:S)) -> EQ(x:S,y:S)
 EQ(O(x:S),0(y:S)) -> EQ(x:S,y:S)
 GUESS(cons(clause:S,cnf:S)) -> CHOICE(clause:S)
 GUESS(cons(clause:S,cnf:S)) -> GUESS(cnf:S)
 MEMBER(x:S,cons(y:S,ys:S)) -> EQ(x:S,y:S)
 MEMBER(x:S,cons(y:S,ys:S)) -> IF(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 MEMBER(x:S,cons(y:S,ys:S)) -> MEMBER(x:S,ys:S)
 SAT(cnf:S) -> GUESS(cnf:S)
 SAT(cnf:S) -> SATCK(cnf:S,guess(cnf:S))
 SATCK(cnf:S,assign:S) -> IF(verify(assign:S),assign:S,unsat)
 SATCK(cnf:S,assign:S) -> VERIFY(assign:S)
 VERIFY(cons(l:S,ls:S)) -> IF(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 VERIFY(cons(l:S,ls:S)) -> MEMBER(negate(l:S),ls:S)
 VERIFY(cons(l:S,ls:S)) -> NEGATE(l:S)
 VERIFY(cons(l:S,ls:S)) -> VERIFY(ls:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 EQ(1(x:S),1(y:S)) -> EQ(x:S,y:S)
 EQ(O(x:S),0(y:S)) -> EQ(x:S,y:S)
->->-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->->Cycle:
->->-> Pairs:
 MEMBER(x:S,cons(y:S,ys:S)) -> MEMBER(x:S,ys:S)
->->-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->->Cycle:
->->-> Pairs:
 VERIFY(cons(l:S,ls:S)) -> VERIFY(ls:S)
->->-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->->Cycle:
->->-> Pairs:
 CHOICE(cons(x:S,xs:S)) -> CHOICE(xs:S)
->->-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->->Cycle:
->->-> Pairs:
 GUESS(cons(clause:S,cnf:S)) -> GUESS(cnf:S)
->->-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue


The problem is decomposed in 5 subproblems.

Problem 1.1: 

Subterm Processor:
-> Pairs:
 EQ(1(x:S),1(y:S)) -> EQ(x:S,y:S)
 EQ(O(x:S),0(y:S)) -> EQ(x:S,y:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Projection:
 pi(EQ) = 1

Problem 1.1: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

Subterm Processor:
-> Pairs:
 MEMBER(x:S,cons(y:S,ys:S)) -> MEMBER(x:S,ys:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Projection:
 pi(MEMBER) = 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.3: 

Subterm Processor:
-> Pairs:
 VERIFY(cons(l:S,ls:S)) -> VERIFY(ls:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Projection:
 pi(VERIFY) = 1

Problem 1.3: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.4: 

Subterm Processor:
-> Pairs:
 CHOICE(cons(x:S,xs:S)) -> CHOICE(xs:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Projection:
 pi(CHOICE) = 1

Problem 1.4: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.5: 

Subterm Processor:
-> Pairs:
 GUESS(cons(clause:S,cnf:S)) -> GUESS(cnf:S)
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Projection:
 pi(GUESS) = 1

Problem 1.5: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 choice(cons(x:S,xs:S)) -> choice(xs:S)
 choice(cons(x:S,xs:S)) -> x:S
 eq(0(x:S),1(y:S)) -> ffalse
 eq(1(x:S),0(y:S)) -> ffalse
 eq(1(x:S),1(y:S)) -> eq(x:S,y:S)
 eq(O(x:S),0(y:S)) -> eq(x:S,y:S)
 eq(nil,nil) -> ttrue
 guess(cons(clause:S,cnf:S)) -> cons(choice(clause:S),guess(cnf:S))
 guess(nil) -> nil
 if(ffalse,t:S,e:S) -> e:S
 if(ttrue,t:S,e:S) -> t:S
 member(x:S,cons(y:S,ys:S)) -> if(eq(x:S,y:S),ttrue,member(x:S,ys:S))
 member(x:S,nil) -> ffalse
 negate(0(x:S)) -> 1(x:S)
 negate(1(x:S)) -> 0(x:S)
 sat(cnf:S) -> satck(cnf:S,guess(cnf:S))
 satck(cnf:S,assign:S) -> if(verify(assign:S),assign:S,unsat)
 verify(cons(l:S,ls:S)) -> if(member(negate(l:S),ls:S),ffalse,verify(ls:S))
 verify(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.