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


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


YES

Problem:
 and(true(),y) -> y
 and(false(),y) -> false()
 eq(nil(),nil()) -> true()
 eq(cons(t,l),nil()) -> false()
 eq(nil(),cons(t,l)) -> false()
 eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
 eq(var(l),var(l')) -> eq(l,l')
 eq(var(l),apply(t,s)) -> false()
 eq(var(l),lambda(x,t)) -> false()
 eq(apply(t,s),var(l)) -> false()
 eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
 eq(apply(t,s),lambda(x,t)) -> false()
 eq(lambda(x,t),var(l)) -> false()
 eq(lambda(x,t),apply(t,s)) -> false()
 eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
 if(true(),var(k),var(l')) -> var(k)
 if(false(),var(k),var(l')) -> var(l')
 ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
 ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
 ren(x,y,lambda(z,t)) ->
 lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren(z,var
                                                                   (cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                 t)))

Proof:
 DP Processor:
  DPs:
   eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
   eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
   eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
   eq#(var(l),var(l')) -> eq#(l,l')
   eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
   eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
   eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
   eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
   eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
   eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
   ren#(var(l),var(k),var(l')) -> eq#(l,l')
   ren#(var(l),var(k),var(l')) -> if#(eq(l,l'),var(k),var(l'))
   ren#(x,y,apply(t,s)) -> ren#(x,y,s)
   ren#(x,y,apply(t,s)) -> ren#(x,y,t)
   ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
   ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
  TRS:
   and(true(),y) -> y
   and(false(),y) -> false()
   eq(nil(),nil()) -> true()
   eq(cons(t,l),nil()) -> false()
   eq(nil(),cons(t,l)) -> false()
   eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
   eq(var(l),var(l')) -> eq(l,l')
   eq(var(l),apply(t,s)) -> false()
   eq(var(l),lambda(x,t)) -> false()
   eq(apply(t,s),var(l)) -> false()
   eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
   eq(apply(t,s),lambda(x,t)) -> false()
   eq(lambda(x,t),var(l)) -> false()
   eq(lambda(x,t),apply(t,s)) -> false()
   eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
   if(true(),var(k),var(l')) -> var(k)
   if(false(),var(k),var(l')) -> var(l')
   ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
   ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
   ren(x,y,lambda(z,t)) ->
   lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren(z,
                                                                   var
                                                                   (cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                   t)))
  TDG Processor:
   DPs:
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    ren#(var(l),var(k),var(l')) -> eq#(l,l')
    ren#(var(l),var(k),var(l')) -> if#(eq(l,l'),var(k),var(l'))
    ren#(x,y,apply(t,s)) -> ren#(x,y,s)
    ren#(x,y,apply(t,s)) -> ren#(x,y,t)
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
   TRS:
    and(true(),y) -> y
    and(false(),y) -> false()
    eq(nil(),nil()) -> true()
    eq(cons(t,l),nil()) -> false()
    eq(nil(),cons(t,l)) -> false()
    eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
    eq(var(l),var(l')) -> eq(l,l')
    eq(var(l),apply(t,s)) -> false()
    eq(var(l),lambda(x,t)) -> false()
    eq(apply(t,s),var(l)) -> false()
    eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
    eq(apply(t,s),lambda(x,t)) -> false()
    eq(lambda(x,t),var(l)) -> false()
    eq(lambda(x,t),apply(t,s)) -> false()
    eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
    if(true(),var(k),var(l')) -> var(k)
    if(false(),var(k),var(l')) -> var(l')
    ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
    ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
    ren(x,y,lambda(z,t)) ->
    lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren(z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
   graph:
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    ren#(var(l),var(k),var(l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t) ->
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t) ->
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,t)
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,s)
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t) ->
    ren#(var(l),var(k),var(l')) -> if#(eq(l,l'),var(k),var(l'))
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t) ->
    ren#(var(l),var(k),var(l')) -> eq#(l,l')
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)) ->
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)) ->
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,t)
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,s)
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)) ->
    ren#(var(l),var(k),var(l')) -> if#(eq(l,l'),var(k),var(l'))
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)) ->
    ren#(var(l),var(k),var(l')) -> eq#(l,l')
    ren#(x,y,apply(t,s)) -> ren#(x,y,s) ->
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
    ren#(x,y,apply(t,s)) -> ren#(x,y,s) ->
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
    ren#(x,y,apply(t,s)) -> ren#(x,y,s) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,t)
    ren#(x,y,apply(t,s)) -> ren#(x,y,s) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,s)
    ren#(x,y,apply(t,s)) -> ren#(x,y,s) ->
    ren#(var(l),var(k),var(l')) -> if#(eq(l,l'),var(k),var(l'))
    ren#(x,y,apply(t,s)) -> ren#(x,y,s) ->
    ren#(var(l),var(k),var(l')) -> eq#(l,l')
    ren#(x,y,apply(t,s)) -> ren#(x,y,t) ->
    ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
    ren#(x,y,apply(t,s)) -> ren#(x,y,t) ->
    ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
    ren#(x,y,apply(t,s)) -> ren#(x,y,t) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,t)
    ren#(x,y,apply(t,s)) -> ren#(x,y,t) ->
    ren#(x,y,apply(t,s)) -> ren#(x,y,s)
    ren#(x,y,apply(t,s)) -> ren#(x,y,t) ->
    ren#(var(l),var(k),var(l')) -> if#(eq(l,l'),var(k),var(l'))
    ren#(x,y,apply(t,s)) -> ren#(x,y,t) ->
    ren#(var(l),var(k),var(l')) -> eq#(l,l')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(var(l),var(l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> and#(eq(x,x'),eq(t,t'))
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> and#(eq(t,t'),eq(s,s'))
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(var(l),var(l')) -> eq#(l,l')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> and#(eq(t,t'),eq(l,l'))
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') ->
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
    eq#(cons(t,l),cons(t',l')) -> eq#(t,t') -> eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
   SCC Processor:
    #sccs: 2
    #rules: 11
    #arcs: 104/256
    DPs:
     ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
     ren#(x,y,apply(t,s)) -> ren#(x,y,s)
     ren#(x,y,apply(t,s)) -> ren#(x,y,t)
     ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
    TRS:
     and(true(),y) -> y
     and(false(),y) -> false()
     eq(nil(),nil()) -> true()
     eq(cons(t,l),nil()) -> false()
     eq(nil(),cons(t,l)) -> false()
     eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
     eq(var(l),var(l')) -> eq(l,l')
     eq(var(l),apply(t,s)) -> false()
     eq(var(l),lambda(x,t)) -> false()
     eq(apply(t,s),var(l)) -> false()
     eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
     eq(apply(t,s),lambda(x,t)) -> false()
     eq(lambda(x,t),var(l)) -> false()
     eq(lambda(x,t),apply(t,s)) -> false()
     eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
     if(true(),var(k),var(l')) -> var(k)
     if(false(),var(k),var(l')) -> var(l')
     ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
     ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
     ren(x,y,lambda(z,t)) ->
     lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren(
                                                                    z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
    KBO Processor:
     argument filtering:
      pi(true) = []
      pi(and) = [0,1]
      pi(false) = []
      pi(nil) = []
      pi(eq) = []
      pi(cons) = []
      pi(var) = []
      pi(apply) = [0,1]
      pi(lambda) = 1
      pi(if) = 2
      pi(ren) = 2
      pi(ren#) = 2
     usable rules:
      if(true(),var(k),var(l')) -> var(k)
      if(false(),var(k),var(l')) -> var(l')
      ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
      ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
      ren(x,y,lambda(z,t)) ->
      lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren
                                                                  (z,
                                                                   var
                                                                   (cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                   t)))
     weight function:
      w0 = 1
      w(ren#) = w(if) = w(apply) = w(var) = w(cons) = w(eq) = w(nil) = w(
      false) = w(and) = w(true) = 1
      w(ren) = w(lambda) = 0
     precedence:
      ren# ~ ren ~ if ~ lambda ~ apply ~ var ~ cons ~ eq ~ nil ~ false ~ and ~ true
     problem:
      DPs:
       ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
       ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
      TRS:
       and(true(),y) -> y
       and(false(),y) -> false()
       eq(nil(),nil()) -> true()
       eq(cons(t,l),nil()) -> false()
       eq(nil(),cons(t,l)) -> false()
       eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
       eq(var(l),var(l')) -> eq(l,l')
       eq(var(l),apply(t,s)) -> false()
       eq(var(l),lambda(x,t)) -> false()
       eq(apply(t,s),var(l)) -> false()
       eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
       eq(apply(t,s),lambda(x,t)) -> false()
       eq(lambda(x,t),var(l)) -> false()
       eq(lambda(x,t),apply(t,s)) -> false()
       eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
       if(true(),var(k),var(l')) -> var(k)
       if(false(),var(k),var(l')) -> var(l')
       ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
       ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
       ren(x,y,lambda(z,t)) ->
       lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren
                                                                   (z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
     Restore Modifier:
      DPs:
       ren#(x,y,lambda(z,t)) -> ren#(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t)
       ren#(x,y,lambda(z,t)) -> ren#(x,y,ren(z,var(cons(x,cons(y,cons(lambda(z,t),nil())))),t))
      TRS:
       and(true(),y) -> y
       and(false(),y) -> false()
       eq(nil(),nil()) -> true()
       eq(cons(t,l),nil()) -> false()
       eq(nil(),cons(t,l)) -> false()
       eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
       eq(var(l),var(l')) -> eq(l,l')
       eq(var(l),apply(t,s)) -> false()
       eq(var(l),lambda(x,t)) -> false()
       eq(apply(t,s),var(l)) -> false()
       eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
       eq(apply(t,s),lambda(x,t)) -> false()
       eq(lambda(x,t),var(l)) -> false()
       eq(lambda(x,t),apply(t,s)) -> false()
       eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
       if(true(),var(k),var(l')) -> var(k)
       if(false(),var(k),var(l')) -> var(l')
       ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
       ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
       ren(x,y,lambda(z,t)) ->
       lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren
                                                                   (z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
      KBO Processor:
       argument filtering:
        pi(true) = []
        pi(and) = [0,1]
        pi(false) = []
        pi(nil) = []
        pi(eq) = []
        pi(cons) = []
        pi(var) = []
        pi(apply) = 1
        pi(lambda) = [1]
        pi(if) = 1
        pi(ren) = 2
        pi(ren#) = 2
       usable rules:
        if(true(),var(k),var(l')) -> var(k)
        if(false(),var(k),var(l')) -> var(l')
        ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
        ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
        ren(x,y,lambda(z,t)) ->
        lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren
                                                                    (
                                                                    z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
       weight function:
        w0 = 1
        w(ren#) = w(lambda) = w(apply) = w(var) = w(cons) = w(eq) = w(
        nil) = w(false) = w(and) = w(true) = 1
        w(ren) = w(if) = 0
       precedence:
        ren# ~ ren ~ if ~ lambda ~ apply ~ var ~ cons ~ eq ~ nil ~ false ~ and ~ true
       problem:
        DPs:
         
        TRS:
         and(true(),y) -> y
         and(false(),y) -> false()
         eq(nil(),nil()) -> true()
         eq(cons(t,l),nil()) -> false()
         eq(nil(),cons(t,l)) -> false()
         eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
         eq(var(l),var(l')) -> eq(l,l')
         eq(var(l),apply(t,s)) -> false()
         eq(var(l),lambda(x,t)) -> false()
         eq(apply(t,s),var(l)) -> false()
         eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
         eq(apply(t,s),lambda(x,t)) -> false()
         eq(lambda(x,t),var(l)) -> false()
         eq(lambda(x,t),apply(t,s)) -> false()
         eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
         if(true(),var(k),var(l')) -> var(k)
         if(false(),var(k),var(l')) -> var(l')
         ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
         ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
         ren(x,y,lambda(z,t)) ->
         lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,
                                                                 ren(
                                                                    z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
       Qed
    
    DPs:
     eq#(cons(t,l),cons(t',l')) -> eq#(l,l')
     eq#(cons(t,l),cons(t',l')) -> eq#(t,t')
     eq#(var(l),var(l')) -> eq#(l,l')
     eq#(apply(t,s),apply(t',s')) -> eq#(s,s')
     eq#(apply(t,s),apply(t',s')) -> eq#(t,t')
     eq#(lambda(x,t),lambda(x',t')) -> eq#(t,t')
     eq#(lambda(x,t),lambda(x',t')) -> eq#(x,x')
    TRS:
     and(true(),y) -> y
     and(false(),y) -> false()
     eq(nil(),nil()) -> true()
     eq(cons(t,l),nil()) -> false()
     eq(nil(),cons(t,l)) -> false()
     eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
     eq(var(l),var(l')) -> eq(l,l')
     eq(var(l),apply(t,s)) -> false()
     eq(var(l),lambda(x,t)) -> false()
     eq(apply(t,s),var(l)) -> false()
     eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
     eq(apply(t,s),lambda(x,t)) -> false()
     eq(lambda(x,t),var(l)) -> false()
     eq(lambda(x,t),apply(t,s)) -> false()
     eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
     if(true(),var(k),var(l')) -> var(k)
     if(false(),var(k),var(l')) -> var(l')
     ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
     ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
     ren(x,y,lambda(z,t)) ->
     lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren(
                                                                    z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
    Subterm Criterion Processor:
     simple projection:
      pi(eq#) = 0
     problem:
      DPs:
       
      TRS:
       and(true(),y) -> y
       and(false(),y) -> false()
       eq(nil(),nil()) -> true()
       eq(cons(t,l),nil()) -> false()
       eq(nil(),cons(t,l)) -> false()
       eq(cons(t,l),cons(t',l')) -> and(eq(t,t'),eq(l,l'))
       eq(var(l),var(l')) -> eq(l,l')
       eq(var(l),apply(t,s)) -> false()
       eq(var(l),lambda(x,t)) -> false()
       eq(apply(t,s),var(l)) -> false()
       eq(apply(t,s),apply(t',s')) -> and(eq(t,t'),eq(s,s'))
       eq(apply(t,s),lambda(x,t)) -> false()
       eq(lambda(x,t),var(l)) -> false()
       eq(lambda(x,t),apply(t,s)) -> false()
       eq(lambda(x,t),lambda(x',t')) -> and(eq(x,x'),eq(t,t'))
       if(true(),var(k),var(l')) -> var(k)
       if(false(),var(k),var(l')) -> var(l')
       ren(var(l),var(k),var(l')) -> if(eq(l,l'),var(k),var(l'))
       ren(x,y,apply(t,s)) -> apply(ren(x,y,t),ren(x,y,s))
       ren(x,y,lambda(z,t)) ->
       lambda(var(cons(x,cons(y,cons(lambda(z,t),nil())))),ren(x,y,ren
                                                                   (z,
                                                                    var
                                                                    (
                                                                    cons
                                                                    (
                                                                    x,
                                                                    cons
                                                                    (y,cons(lambda(z,t),nil())))),
                                                                    t)))
     Qed