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

Recursive Path Order [RPO].
Precedence:
[REN2, lambda1] > [var, cons]
apply2 > [var, cons]
nil > [var, cons]
eq > [false, true] > [var, cons]


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:
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.

(11) PisEmptyProof (EQUIVALENT transformation)

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

(12) TRUE