/export/starexec/sandbox2/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


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


YES

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

Proof:
 DP Processor:
  DPs:
   member#(x,cons(y,ys)) -> member#(x,ys)
   member#(x,cons(y,ys)) -> eq#(x,y)
   member#(x,cons(y,ys)) -> if#(eq(x,y),true(),member(x,ys))
   eq#(O(x),0(y)) -> eq#(x,y)
   eq#(1(x),1(y)) -> eq#(x,y)
   choice#(cons(x,xs)) -> choice#(xs)
   guess#(cons(clause,cnf)) -> guess#(cnf)
   guess#(cons(clause,cnf)) -> choice#(clause)
   verify#(cons(l,ls)) -> verify#(ls)
   verify#(cons(l,ls)) -> negate#(l)
   verify#(cons(l,ls)) -> member#(negate(l),ls)
   verify#(cons(l,ls)) -> if#(member(negate(l),ls),false(),verify(ls))
   sat#(cnf) -> guess#(cnf)
   sat#(cnf) -> satck#(cnf,guess(cnf))
   satck#(cnf,assign) -> verify#(assign)
   satck#(cnf,assign) -> if#(verify(assign),assign,unsat())
  TRS:
   if(true(),t,e) -> t
   if(false(),t,e) -> e
   member(x,nil()) -> false()
   member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
   eq(nil(),nil()) -> true()
   eq(O(x),0(y)) -> eq(x,y)
   eq(0(x),1(y)) -> false()
   eq(1(x),0(y)) -> false()
   eq(1(x),1(y)) -> eq(x,y)
   negate(0(x)) -> 1(x)
   negate(1(x)) -> 0(x)
   choice(cons(x,xs)) -> x
   choice(cons(x,xs)) -> choice(xs)
   guess(nil()) -> nil()
   guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
   verify(nil()) -> true()
   verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
   sat(cnf) -> satck(cnf,guess(cnf))
   satck(cnf,assign) -> if(verify(assign),assign,unsat())
  TDG Processor:
   DPs:
    member#(x,cons(y,ys)) -> member#(x,ys)
    member#(x,cons(y,ys)) -> eq#(x,y)
    member#(x,cons(y,ys)) -> if#(eq(x,y),true(),member(x,ys))
    eq#(O(x),0(y)) -> eq#(x,y)
    eq#(1(x),1(y)) -> eq#(x,y)
    choice#(cons(x,xs)) -> choice#(xs)
    guess#(cons(clause,cnf)) -> guess#(cnf)
    guess#(cons(clause,cnf)) -> choice#(clause)
    verify#(cons(l,ls)) -> verify#(ls)
    verify#(cons(l,ls)) -> negate#(l)
    verify#(cons(l,ls)) -> member#(negate(l),ls)
    verify#(cons(l,ls)) -> if#(member(negate(l),ls),false(),verify(ls))
    sat#(cnf) -> guess#(cnf)
    sat#(cnf) -> satck#(cnf,guess(cnf))
    satck#(cnf,assign) -> verify#(assign)
    satck#(cnf,assign) -> if#(verify(assign),assign,unsat())
   TRS:
    if(true(),t,e) -> t
    if(false(),t,e) -> e
    member(x,nil()) -> false()
    member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
    eq(nil(),nil()) -> true()
    eq(O(x),0(y)) -> eq(x,y)
    eq(0(x),1(y)) -> false()
    eq(1(x),0(y)) -> false()
    eq(1(x),1(y)) -> eq(x,y)
    negate(0(x)) -> 1(x)
    negate(1(x)) -> 0(x)
    choice(cons(x,xs)) -> x
    choice(cons(x,xs)) -> choice(xs)
    guess(nil()) -> nil()
    guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
    verify(nil()) -> true()
    verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
    sat(cnf) -> satck(cnf,guess(cnf))
    satck(cnf,assign) -> if(verify(assign),assign,unsat())
   graph:
    satck#(cnf,assign) -> verify#(assign) ->
    verify#(cons(l,ls)) -> if#(member(negate(l),ls),false(),verify(ls))
    satck#(cnf,assign) -> verify#(assign) ->
    verify#(cons(l,ls)) -> member#(negate(l),ls)
    satck#(cnf,assign) -> verify#(assign) ->
    verify#(cons(l,ls)) -> negate#(l)
    satck#(cnf,assign) -> verify#(assign) ->
    verify#(cons(l,ls)) -> verify#(ls)
    sat#(cnf) -> satck#(cnf,guess(cnf)) ->
    satck#(cnf,assign) -> if#(verify(assign),assign,unsat())
    sat#(cnf) -> satck#(cnf,guess(cnf)) ->
    satck#(cnf,assign) -> verify#(assign)
    sat#(cnf) -> guess#(cnf) -> guess#(cons(clause,cnf)) -> choice#(clause)
    sat#(cnf) -> guess#(cnf) ->
    guess#(cons(clause,cnf)) -> guess#(cnf)
    verify#(cons(l,ls)) -> verify#(ls) ->
    verify#(cons(l,ls)) -> if#(member(negate(l),ls),false(),verify(ls))
    verify#(cons(l,ls)) -> verify#(ls) ->
    verify#(cons(l,ls)) -> member#(negate(l),ls)
    verify#(cons(l,ls)) -> verify#(ls) ->
    verify#(cons(l,ls)) -> negate#(l)
    verify#(cons(l,ls)) -> verify#(ls) ->
    verify#(cons(l,ls)) -> verify#(ls)
    verify#(cons(l,ls)) -> member#(negate(l),ls) ->
    member#(x,cons(y,ys)) -> if#(eq(x,y),true(),member(x,ys))
    verify#(cons(l,ls)) -> member#(negate(l),ls) ->
    member#(x,cons(y,ys)) -> eq#(x,y)
    verify#(cons(l,ls)) -> member#(negate(l),ls) ->
    member#(x,cons(y,ys)) -> member#(x,ys)
    guess#(cons(clause,cnf)) -> guess#(cnf) ->
    guess#(cons(clause,cnf)) -> choice#(clause)
    guess#(cons(clause,cnf)) -> guess#(cnf) ->
    guess#(cons(clause,cnf)) -> guess#(cnf)
    guess#(cons(clause,cnf)) -> choice#(clause) ->
    choice#(cons(x,xs)) -> choice#(xs)
    choice#(cons(x,xs)) -> choice#(xs) ->
    choice#(cons(x,xs)) -> choice#(xs)
    eq#(1(x),1(y)) -> eq#(x,y) -> eq#(1(x),1(y)) -> eq#(x,y)
    eq#(1(x),1(y)) -> eq#(x,y) -> eq#(O(x),0(y)) -> eq#(x,y)
    eq#(O(x),0(y)) -> eq#(x,y) -> eq#(1(x),1(y)) -> eq#(x,y)
    eq#(O(x),0(y)) -> eq#(x,y) -> eq#(O(x),0(y)) -> eq#(x,y)
    member#(x,cons(y,ys)) -> eq#(x,y) ->
    eq#(1(x),1(y)) -> eq#(x,y)
    member#(x,cons(y,ys)) -> eq#(x,y) ->
    eq#(O(x),0(y)) -> eq#(x,y)
    member#(x,cons(y,ys)) -> member#(x,ys) ->
    member#(x,cons(y,ys)) -> if#(eq(x,y),true(),member(x,ys))
    member#(x,cons(y,ys)) -> member#(x,ys) ->
    member#(x,cons(y,ys)) -> eq#(x,y)
    member#(x,cons(y,ys)) -> member#(x,ys) -> member#(x,cons(y,ys)) -> member#(x,ys)
   SCC Processor:
    #sccs: 5
    #rules: 6
    #arcs: 28/256
    DPs:
     guess#(cons(clause,cnf)) -> guess#(cnf)
    TRS:
     if(true(),t,e) -> t
     if(false(),t,e) -> e
     member(x,nil()) -> false()
     member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
     eq(nil(),nil()) -> true()
     eq(O(x),0(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(1(x),1(y)) -> eq(x,y)
     negate(0(x)) -> 1(x)
     negate(1(x)) -> 0(x)
     choice(cons(x,xs)) -> x
     choice(cons(x,xs)) -> choice(xs)
     guess(nil()) -> nil()
     guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
     verify(nil()) -> true()
     verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
     sat(cnf) -> satck(cnf,guess(cnf))
     satck(cnf,assign) -> if(verify(assign),assign,unsat())
    Subterm Criterion Processor:
     simple projection:
      pi(guess#) = 0
     problem:
      DPs:
       
      TRS:
       if(true(),t,e) -> t
       if(false(),t,e) -> e
       member(x,nil()) -> false()
       member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
       eq(nil(),nil()) -> true()
       eq(O(x),0(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(1(x),1(y)) -> eq(x,y)
       negate(0(x)) -> 1(x)
       negate(1(x)) -> 0(x)
       choice(cons(x,xs)) -> x
       choice(cons(x,xs)) -> choice(xs)
       guess(nil()) -> nil()
       guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
       verify(nil()) -> true()
       verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
       sat(cnf) -> satck(cnf,guess(cnf))
       satck(cnf,assign) -> if(verify(assign),assign,unsat())
     Qed
    
    DPs:
     choice#(cons(x,xs)) -> choice#(xs)
    TRS:
     if(true(),t,e) -> t
     if(false(),t,e) -> e
     member(x,nil()) -> false()
     member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
     eq(nil(),nil()) -> true()
     eq(O(x),0(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(1(x),1(y)) -> eq(x,y)
     negate(0(x)) -> 1(x)
     negate(1(x)) -> 0(x)
     choice(cons(x,xs)) -> x
     choice(cons(x,xs)) -> choice(xs)
     guess(nil()) -> nil()
     guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
     verify(nil()) -> true()
     verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
     sat(cnf) -> satck(cnf,guess(cnf))
     satck(cnf,assign) -> if(verify(assign),assign,unsat())
    Subterm Criterion Processor:
     simple projection:
      pi(choice#) = 0
     problem:
      DPs:
       
      TRS:
       if(true(),t,e) -> t
       if(false(),t,e) -> e
       member(x,nil()) -> false()
       member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
       eq(nil(),nil()) -> true()
       eq(O(x),0(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(1(x),1(y)) -> eq(x,y)
       negate(0(x)) -> 1(x)
       negate(1(x)) -> 0(x)
       choice(cons(x,xs)) -> x
       choice(cons(x,xs)) -> choice(xs)
       guess(nil()) -> nil()
       guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
       verify(nil()) -> true()
       verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
       sat(cnf) -> satck(cnf,guess(cnf))
       satck(cnf,assign) -> if(verify(assign),assign,unsat())
     Qed
    
    DPs:
     verify#(cons(l,ls)) -> verify#(ls)
    TRS:
     if(true(),t,e) -> t
     if(false(),t,e) -> e
     member(x,nil()) -> false()
     member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
     eq(nil(),nil()) -> true()
     eq(O(x),0(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(1(x),1(y)) -> eq(x,y)
     negate(0(x)) -> 1(x)
     negate(1(x)) -> 0(x)
     choice(cons(x,xs)) -> x
     choice(cons(x,xs)) -> choice(xs)
     guess(nil()) -> nil()
     guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
     verify(nil()) -> true()
     verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
     sat(cnf) -> satck(cnf,guess(cnf))
     satck(cnf,assign) -> if(verify(assign),assign,unsat())
    Subterm Criterion Processor:
     simple projection:
      pi(verify#) = 0
     problem:
      DPs:
       
      TRS:
       if(true(),t,e) -> t
       if(false(),t,e) -> e
       member(x,nil()) -> false()
       member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
       eq(nil(),nil()) -> true()
       eq(O(x),0(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(1(x),1(y)) -> eq(x,y)
       negate(0(x)) -> 1(x)
       negate(1(x)) -> 0(x)
       choice(cons(x,xs)) -> x
       choice(cons(x,xs)) -> choice(xs)
       guess(nil()) -> nil()
       guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
       verify(nil()) -> true()
       verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
       sat(cnf) -> satck(cnf,guess(cnf))
       satck(cnf,assign) -> if(verify(assign),assign,unsat())
     Qed
    
    DPs:
     member#(x,cons(y,ys)) -> member#(x,ys)
    TRS:
     if(true(),t,e) -> t
     if(false(),t,e) -> e
     member(x,nil()) -> false()
     member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
     eq(nil(),nil()) -> true()
     eq(O(x),0(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(1(x),1(y)) -> eq(x,y)
     negate(0(x)) -> 1(x)
     negate(1(x)) -> 0(x)
     choice(cons(x,xs)) -> x
     choice(cons(x,xs)) -> choice(xs)
     guess(nil()) -> nil()
     guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
     verify(nil()) -> true()
     verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
     sat(cnf) -> satck(cnf,guess(cnf))
     satck(cnf,assign) -> if(verify(assign),assign,unsat())
    Subterm Criterion Processor:
     simple projection:
      pi(member#) = 1
     problem:
      DPs:
       
      TRS:
       if(true(),t,e) -> t
       if(false(),t,e) -> e
       member(x,nil()) -> false()
       member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
       eq(nil(),nil()) -> true()
       eq(O(x),0(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(1(x),1(y)) -> eq(x,y)
       negate(0(x)) -> 1(x)
       negate(1(x)) -> 0(x)
       choice(cons(x,xs)) -> x
       choice(cons(x,xs)) -> choice(xs)
       guess(nil()) -> nil()
       guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
       verify(nil()) -> true()
       verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
       sat(cnf) -> satck(cnf,guess(cnf))
       satck(cnf,assign) -> if(verify(assign),assign,unsat())
     Qed
    
    DPs:
     eq#(O(x),0(y)) -> eq#(x,y)
     eq#(1(x),1(y)) -> eq#(x,y)
    TRS:
     if(true(),t,e) -> t
     if(false(),t,e) -> e
     member(x,nil()) -> false()
     member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
     eq(nil(),nil()) -> true()
     eq(O(x),0(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(1(x),1(y)) -> eq(x,y)
     negate(0(x)) -> 1(x)
     negate(1(x)) -> 0(x)
     choice(cons(x,xs)) -> x
     choice(cons(x,xs)) -> choice(xs)
     guess(nil()) -> nil()
     guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
     verify(nil()) -> true()
     verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
     sat(cnf) -> satck(cnf,guess(cnf))
     satck(cnf,assign) -> if(verify(assign),assign,unsat())
    Subterm Criterion Processor:
     simple projection:
      pi(eq#) = 0
     problem:
      DPs:
       
      TRS:
       if(true(),t,e) -> t
       if(false(),t,e) -> e
       member(x,nil()) -> false()
       member(x,cons(y,ys)) -> if(eq(x,y),true(),member(x,ys))
       eq(nil(),nil()) -> true()
       eq(O(x),0(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(1(x),1(y)) -> eq(x,y)
       negate(0(x)) -> 1(x)
       negate(1(x)) -> 0(x)
       choice(cons(x,xs)) -> x
       choice(cons(x,xs)) -> choice(xs)
       guess(nil()) -> nil()
       guess(cons(clause,cnf)) -> cons(choice(clause),guess(cnf))
       verify(nil()) -> true()
       verify(cons(l,ls)) -> if(member(negate(l),ls),false(),verify(ls))
       sat(cnf) -> satck(cnf,guess(cnf))
       satck(cnf,assign) -> if(verify(assign),assign,unsat())
     Qed