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


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


YES

Problem 1: 

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

Problem 1: 

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

Problem 1: 

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


The problem is decomposed in 5 subproblems.

Problem 1.1: 

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

Problem 1.1: 

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

The problem is finite.

Problem 1.2: 

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

Problem 1.2: 

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

The problem is finite.

Problem 1.3: 

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

Problem 1.3: 

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

The problem is finite.

Problem 1.4: 

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

Problem 1.4: 

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

The problem is finite.

Problem 1.5: 

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

Problem 1.5: 

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

The problem is finite.