(0) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

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)))

Q is empty.

(1) Overlay + Local Confluence (EQUIVALENT transformation)

The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.

(2) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

(3) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.

(4) Obligation:

Q DP problem:
The TRS P consists of the following rules:

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(L, Lp)
EQ(var(L), var(Lp)) → EQ(L, Lp)
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(S, Sp)
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(X, Xp)
REN(var(L), var(K), var(Lp)) → IF(eq(L, Lp), var(K), var(Lp))
REN(var(L), var(K), var(Lp)) → EQ(L, Lp)
REN(X, Y, apply(T, S)) → REN(X, Y, 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(X, Y, lambda(Z, T)) → REN(Z, var(cons(X, cons(Y, cons(lambda(Z, T), nil)))), T)

The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

We have to consider all minimal (P,Q,R)-chains.

(5) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 5 less nodes.

(6) Complex Obligation (AND)

(7) Obligation:

Q DP problem:
The TRS P consists of the following rules:

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(T, Tp)
EQ(apply(T, S), apply(Tp, Sp)) → EQ(S, Sp)
EQ(lambda(X, T), lambda(Xp, Tp)) → EQ(T, Tp)
EQ(lambda(X, T), lambda(Xp, Tp)) → EQ(X, Xp)

The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

We have to consider all minimal (P,Q,R)-chains.

(8) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


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(T, Tp)
EQ(apply(T, S), apply(Tp, Sp)) → EQ(S, Sp)
EQ(lambda(X, T), lambda(Xp, Tp)) → EQ(T, Tp)
EQ(lambda(X, T), lambda(Xp, Tp)) → EQ(X, Xp)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
EQ(x1, x2)  =  EQ(x2)
cons(x1, x2)  =  cons(x1, x2)
var(x1)  =  var(x1)
apply(x1, x2)  =  apply(x1, x2)
lambda(x1, x2)  =  lambda(x1, x2)

Recursive Path Order [RPO].
Precedence:
cons2 > EQ1
var1 > EQ1
apply2 > EQ1
lambda2 > EQ1

The following usable rules [FROCOS05] were oriented: none

(9) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

We have to consider all minimal (P,Q,R)-chains.

(10) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(11) TRUE

(12) Obligation:

Q DP problem:
The TRS P consists of the following rules:

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))
REN(X, Y, lambda(Z, T)) → REN(Z, var(cons(X, cons(Y, cons(lambda(Z, T), nil)))), T)

The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

We have to consider all minimal (P,Q,R)-chains.

(13) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


REN(X, Y, apply(T, S)) → REN(X, Y, S)
REN(X, Y, apply(T, S)) → REN(X, Y, T)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
REN(x1, x2, x3)  =  REN(x3)
apply(x1, x2)  =  apply(x1, x2)
lambda(x1, x2)  =  x2
ren(x1, x2, x3)  =  x3
var(x1)  =  var
cons(x1, x2)  =  cons(x2)
nil  =  nil
if(x1, x2, x3)  =  x2
eq(x1, x2)  =  eq
true  =  true
false  =  false
and(x1, x2)  =  and(x2)

Recursive Path Order [RPO].
Precedence:
REN1 > var
apply2 > var
cons1 > var
nil > true > var
eq > true > var
false > var
and1 > true > var

The following usable rules [FROCOS05] were oriented:

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)))
if(true, var(K), var(L)) → var(K)
if(false, var(K), var(L)) → var(L)

(14) Obligation:

Q DP problem:
The TRS P consists of the following rules:

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)

The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

We have to consider all minimal (P,Q,R)-chains.

(15) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


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)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
REN(x1, x2, x3)  =  REN(x3)
lambda(x1, x2)  =  lambda(x2)
ren(x1, x2, x3)  =  x3
var(x1)  =  var
cons(x1, x2)  =  cons(x2)
nil  =  nil
if(x1, x2, x3)  =  x3
eq(x1, x2)  =  eq
apply(x1, x2)  =  apply(x1, x2)
true  =  true
false  =  false
and(x1, x2)  =  and(x2)

Recursive Path Order [RPO].
Precedence:
REN1 > var
lambda1 > var
cons1 > var
nil > true > var
eq > true > var
apply2 > var
false > var
and1 > true > var

The following usable rules [FROCOS05] were oriented:

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)))
if(true, var(K), var(L)) → var(K)
if(false, var(K), var(L)) → var(L)

(16) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

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)))

The set Q consists of the following terms:

and(false, false)
and(true, false)
and(false, true)
and(true, true)
eq(nil, nil)
eq(cons(x0, x1), nil)
eq(nil, cons(x0, x1))
eq(cons(x0, x1), cons(x2, x3))
eq(var(x0), var(x1))
eq(var(x0), apply(x1, x2))
eq(var(x0), lambda(x1, x2))
eq(apply(x0, x1), var(x2))
eq(apply(x0, x1), apply(x2, x3))
eq(apply(x0, x1), lambda(x2, x3))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x2, x3))
eq(lambda(x0, x1), lambda(x2, x3))
if(true, var(x0), var(x1))
if(false, var(x0), var(x1))
ren(var(x0), var(x1), var(x2))
ren(x0, x1, apply(x2, x3))
ren(x0, x1, lambda(x2, x3))

We have to consider all minimal (P,Q,R)-chains.

(17) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(18) TRUE