/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:
 and(false(),false()) -> false()
 and(true(),false()) -> false()
 and(false(),true()) -> false()
 and(true(),true()) -> true()
 eq(nil(),nil()) -> true()
 eq(cons(T,L),nil()) -> false()
 eq(nil(),cons(T,L)) -> false()
 eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
 eq(var(L),var(Lp)) -> eq(L,Lp)
 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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
 eq(apply(T,S),lambda(X,Tp)) -> false()
 eq(lambda(X,T),var(L)) -> false()
 eq(lambda(X,T),apply(Tp,Sp)) -> false()
 eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
 if(true(),var(K),var(L)) -> var(K)
 if(false(),var(K),var(L)) -> var(L)
 ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
 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(Tp,Lp)) -> eq#(L,Lp)
   eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
   eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
   eq#(var(L),var(Lp)) -> eq#(L,Lp)
   eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
   eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
   eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
   eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
   eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
   eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
   ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp)
   ren#(var(L),var(K),var(Lp)) -> if#(eq(L,Lp),var(K),var(Lp))
   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(false(),false()) -> false()
   and(true(),false()) -> false()
   and(false(),true()) -> false()
   and(true(),true()) -> true()
   eq(nil(),nil()) -> true()
   eq(cons(T,L),nil()) -> false()
   eq(nil(),cons(T,L)) -> false()
   eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
   eq(var(L),var(Lp)) -> eq(L,Lp)
   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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
   eq(apply(T,S),lambda(X,Tp)) -> false()
   eq(lambda(X,T),var(L)) -> false()
   eq(lambda(X,T),apply(Tp,Sp)) -> false()
   eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
   if(true(),var(K),var(L)) -> var(K)
   if(false(),var(K),var(L)) -> var(L)
   ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
   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(Tp,Lp)) -> eq#(L,Lp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp)
    ren#(var(L),var(K),var(Lp)) -> if#(eq(L,Lp),var(K),var(Lp))
    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(false(),false()) -> false()
    and(true(),false()) -> false()
    and(false(),true()) -> false()
    and(true(),true()) -> true()
    eq(nil(),nil()) -> true()
    eq(cons(T,L),nil()) -> false()
    eq(nil(),cons(T,L)) -> false()
    eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
    eq(var(L),var(Lp)) -> eq(L,Lp)
    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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
    eq(apply(T,S),lambda(X,Tp)) -> false()
    eq(lambda(X,T),var(L)) -> false()
    eq(lambda(X,T),apply(Tp,Sp)) -> false()
    eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
    if(true(),var(K),var(L)) -> var(K)
    if(false(),var(K),var(L)) -> var(L)
    ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
    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(Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    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(Lp)) -> if#(eq(L,Lp),var(K),var(Lp))
    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(Lp)) -> eq#(L,Lp)
    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(Lp)) -> if#(eq(L,Lp),var(K),var(Lp))
    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(Lp)) -> eq#(L,Lp)
    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(Lp)) -> if#(eq(L,Lp),var(K),var(Lp))
    ren#(X,Y,apply(T,S)) -> ren#(X,Y,S) ->
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp)
    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(Lp)) -> if#(eq(L,Lp),var(K),var(Lp))
    ren#(X,Y,apply(T,S)) -> ren#(X,Y,T) ->
    ren#(var(L),var(K),var(Lp)) -> eq#(L,Lp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(var(L),var(Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> and#(eq(T,Tp),eq(X,Xp))
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> and#(eq(T,Tp),eq(S,Sp))
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(var(L),var(Lp)) -> eq#(L,Lp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> and#(eq(T,Tp),eq(L,Lp))
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) ->
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
    eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp) -> eq#(cons(T,L),cons(Tp,Lp)) -> eq#(L,Lp)
   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(false(),false()) -> false()
     and(true(),false()) -> false()
     and(false(),true()) -> false()
     and(true(),true()) -> true()
     eq(nil(),nil()) -> true()
     eq(cons(T,L),nil()) -> false()
     eq(nil(),cons(T,L)) -> false()
     eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
     eq(var(L),var(Lp)) -> eq(L,Lp)
     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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
     eq(apply(T,S),lambda(X,Tp)) -> false()
     eq(lambda(X,T),var(L)) -> false()
     eq(lambda(X,T),apply(Tp,Sp)) -> false()
     eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
     if(true(),var(K),var(L)) -> var(K)
     if(false(),var(K),var(L)) -> var(L)
     ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
     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(false) = []
      pi(and) = [0,1]
      pi(true) = []
      pi(nil) = []
      pi(eq) = []
      pi(cons) = []
      pi(var) = []
      pi(apply) = [0,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(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
      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(var) = w(cons) = w(eq) = w(nil) = w(true) = w(
      and) = w(false) = 1
      w(ren) = w(lambda) = w(apply) = 0
     precedence:
      ren# ~ ren ~ if ~ lambda ~ apply ~ var ~ cons ~ eq ~ nil ~ true ~ and ~ false
     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(false(),false()) -> false()
       and(true(),false()) -> false()
       and(false(),true()) -> false()
       and(true(),true()) -> true()
       eq(nil(),nil()) -> true()
       eq(cons(T,L),nil()) -> false()
       eq(nil(),cons(T,L)) -> false()
       eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
       eq(var(L),var(Lp)) -> eq(L,Lp)
       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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
       eq(apply(T,S),lambda(X,Tp)) -> false()
       eq(lambda(X,T),var(L)) -> false()
       eq(lambda(X,T),apply(Tp,Sp)) -> false()
       eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
       if(true(),var(K),var(L)) -> var(K)
       if(false(),var(K),var(L)) -> var(L)
       ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
       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(false(),false()) -> false()
       and(true(),false()) -> false()
       and(false(),true()) -> false()
       and(true(),true()) -> true()
       eq(nil(),nil()) -> true()
       eq(cons(T,L),nil()) -> false()
       eq(nil(),cons(T,L)) -> false()
       eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
       eq(var(L),var(Lp)) -> eq(L,Lp)
       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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
       eq(apply(T,S),lambda(X,Tp)) -> false()
       eq(lambda(X,T),var(L)) -> false()
       eq(lambda(X,T),apply(Tp,Sp)) -> false()
       eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
       if(true(),var(K),var(L)) -> var(K)
       if(false(),var(K),var(L)) -> var(L)
       ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
       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(false) = []
        pi(and) = [0,1]
        pi(true) = []
        pi(nil) = []
        pi(eq) = []
        pi(cons) = []
        pi(var) = []
        pi(apply) = 1
        pi(lambda) = [1]
        pi(if) = 1
        pi(ren) = 2
        pi(ren#) = [1,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(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
        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(lambda) = w(apply) = w(var) = w(cons) = w(
        eq) = w(nil) = w(true) = w(and) = w(false) = 1
        w(ren) = 0
       precedence:
        ren# ~ ren ~ if ~ lambda ~ apply ~ var ~ cons ~ eq ~ nil ~ true ~ and ~ false
       problem:
        DPs:
         
        TRS:
         and(false(),false()) -> false()
         and(true(),false()) -> false()
         and(false(),true()) -> false()
         and(true(),true()) -> true()
         eq(nil(),nil()) -> true()
         eq(cons(T,L),nil()) -> false()
         eq(nil(),cons(T,L)) -> false()
         eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
         eq(var(L),var(Lp)) -> eq(L,Lp)
         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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
         eq(apply(T,S),lambda(X,Tp)) -> false()
         eq(lambda(X,T),var(L)) -> false()
         eq(lambda(X,T),apply(Tp,Sp)) -> false()
         eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
         if(true(),var(K),var(L)) -> var(K)
         if(false(),var(K),var(L)) -> var(L)
         ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
         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(Tp,Lp)) -> eq#(L,Lp)
     eq#(cons(T,L),cons(Tp,Lp)) -> eq#(T,Tp)
     eq#(var(L),var(Lp)) -> eq#(L,Lp)
     eq#(apply(T,S),apply(Tp,Sp)) -> eq#(S,Sp)
     eq#(apply(T,S),apply(Tp,Sp)) -> eq#(T,Tp)
     eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(X,Xp)
     eq#(lambda(X,T),lambda(Xp,Tp)) -> eq#(T,Tp)
    TRS:
     and(false(),false()) -> false()
     and(true(),false()) -> false()
     and(false(),true()) -> false()
     and(true(),true()) -> true()
     eq(nil(),nil()) -> true()
     eq(cons(T,L),nil()) -> false()
     eq(nil(),cons(T,L)) -> false()
     eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
     eq(var(L),var(Lp)) -> eq(L,Lp)
     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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
     eq(apply(T,S),lambda(X,Tp)) -> false()
     eq(lambda(X,T),var(L)) -> false()
     eq(lambda(X,T),apply(Tp,Sp)) -> false()
     eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
     if(true(),var(K),var(L)) -> var(K)
     if(false(),var(K),var(L)) -> var(L)
     ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
     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(false(),false()) -> false()
       and(true(),false()) -> false()
       and(false(),true()) -> false()
       and(true(),true()) -> true()
       eq(nil(),nil()) -> true()
       eq(cons(T,L),nil()) -> false()
       eq(nil(),cons(T,L)) -> false()
       eq(cons(T,L),cons(Tp,Lp)) -> and(eq(T,Tp),eq(L,Lp))
       eq(var(L),var(Lp)) -> eq(L,Lp)
       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(Tp,Sp)) -> and(eq(T,Tp),eq(S,Sp))
       eq(apply(T,S),lambda(X,Tp)) -> false()
       eq(lambda(X,T),var(L)) -> false()
       eq(lambda(X,T),apply(Tp,Sp)) -> false()
       eq(lambda(X,T),lambda(Xp,Tp)) -> and(eq(T,Tp),eq(X,Xp))
       if(true(),var(K),var(L)) -> var(K)
       if(false(),var(K),var(L)) -> var(L)
       ren(var(L),var(K),var(Lp)) -> if(eq(L,Lp),var(K),var(Lp))
       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