(0) Obligation:

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

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

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

The set Q consists of the following terms:

and(true, x0)
and(false, x0)
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, x0))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x1, x2))
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(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(l, l')
EQ(var(l), var(l')) → EQ(l, l')
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(s, s')
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(t, t')
REN(var(l), var(k), var(l')) → IF(eq(l, l'), var(k), var(l'))
REN(var(l), var(k), var(l')) → EQ(l, l')
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(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)))

The set Q consists of the following terms:

and(true, x0)
and(false, x0)
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, x0))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x1, x2))
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(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(t, t')
EQ(apply(t, s), apply(t', s')) → EQ(s, s')
EQ(lambda(x, t), lambda(x', t')) → EQ(x, x')
EQ(lambda(x, t), lambda(x', t')) → EQ(t, t')

The TRS R consists of the following rules:

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

The set Q consists of the following terms:

and(true, x0)
and(false, x0)
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, x0))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x1, x2))
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(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)))

The set Q consists of the following terms:

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

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

Status:
REN1: multiset
apply2: [2,1]
lambda1: [1]
var: multiset
cons1: multiset
nil: multiset
true: multiset
false: multiset
eq: []


The following usable rules [FROCOS05] were oriented:

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

(10) Obligation:

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

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

The set Q consists of the following terms:

and(true, x0)
and(false, x0)
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, x0))
eq(lambda(x0, x1), var(x2))
eq(lambda(x0, x1), apply(x1, x2))
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