Termination w.r.t. Q of the given QTRS could not be shown:

0 QTRS
↳1 Overlay + Local Confluence (⇔)
↳2 QTRS
↳3 DependencyPairsProof (⇔)
↳4 QDP
↳5 DependencyGraphProof (⇔)
↳6 AND
  ↳7 QDP
  ↳8 QDP
    ↳9 QDPOrderProof (⇔)
    ↳10 QDP
    ↳11 QDPOrderProof (⇔)
    ↳12 QDP
    ↳13 PisEmptyProof (⇔)
    ↳14 TRUE

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

(9) 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(x2, x3)
apply(x1, x2)  =  apply(x1, x2)
lambda(x1, x2)  =  x2
ren(x1, x2, x3)  =  x3
var(x1)  =  var
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
and(x1, x2)  =  and
false  =  false
true  =  true
eq(x1, x2)  =  eq
if(x1, x2, x3)  =  if

Recursive path order with status [RPO].
Quasi-Precedence:
[REN2, apply2] > cons2 > [var, false, if]
[REN2, apply2] > nil > true > [var, false, if]
[REN2, apply2] > eq > and > true > [var, false, if]

Status:
REN2: [2,1]
apply2: multiset
var: []
cons2: multiset
nil: multiset
and: []
false: multiset
true: multiset
eq: []
if: []


The following usable rules [FROCOS05] were oriented:

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

(10) 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.

(11) 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)  =  x3
lambda(x1, x2)  =  lambda(x1, x2)
ren(x1, x2, x3)  =  x3
var(x1)  =  var
cons(x1, x2)  =  cons(x2)
nil  =  nil
and(x1, x2)  =  x2
false  =  false
true  =  true
eq(x1, x2)  =  eq
apply(x1, x2)  =  apply(x1, x2)
if(x1, x2, x3)  =  if

Recursive path order with status [RPO].
Quasi-Precedence:
lambda2 > nil > [false, true, eq, apply2] > [var, if]
cons1 > [false, true, eq, apply2] > [var, if]

Status:
lambda2: [2,1]
var: multiset
cons1: multiset
nil: multiset
false: multiset
true: multiset
eq: []
apply2: [2,1]
if: multiset


The following usable rules [FROCOS05] were oriented:

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

(12) 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.

(13) PisEmptyProof (EQUIVALENT transformation)

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

(14) TRUE