(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) DependencyPairsProof (EQUIVALENT transformation)

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

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

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

(3) DependencyGraphProof (EQUIVALENT transformation)

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

(4) Complex Obligation (AND)

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

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

(6) QDPSizeChangeProof (EQUIVALENT transformation)

We used the following order and afs together with the size-change analysis [AAECC05] to show that there are no infinite chains for this DP problem.

Order:Homeomorphic Embedding Order

AFS:
var(x1)  =  var(x1)
apply(x1, x2)  =  apply(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
lambda(x1, x2)  =  lambda(x1, x2)

From the DPs we obtained the following set of size-change graphs:

  • EQ(cons(t, l), cons(t', l')) → EQ(l, l') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

  • EQ(cons(t, l), cons(t', l')) → EQ(t, t') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

  • EQ(var(l), var(l')) → EQ(l, l') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

  • EQ(apply(t, s), apply(t', s')) → EQ(t, t') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

  • EQ(apply(t, s), apply(t', s')) → EQ(s, s') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

  • EQ(lambda(x, t), lambda(x', t')) → EQ(x, x') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

  • EQ(lambda(x, t), lambda(x', t')) → EQ(t, t') (allowed arguments on rhs = {1, 2})
    The graph contains the following edges 1 > 1, 2 > 2

We oriented the following set of usable rules [AAECC05,FROCOS05]. none

(7) TRUE

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

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

(9) QDPSizeChangeProof (EQUIVALENT transformation)

We used the following order and afs together with the size-change analysis [AAECC05] to show that there are no infinite chains for this DP problem.

Order:Combined order from the following AFS and order.
ren(x1, x2, x3)  =  x3
var(x1)  =  var
if(x1, x2, x3)  =  x3
eq(x1, x2)  =  eq(x2)
apply(x1, x2)  =  apply(x1, x2)
lambda(x1, x2)  =  lambda(x2)
cons(x1, x2)  =  cons
nil  =  nil
true  =  true
false  =  false
and(x1, x2)  =  x1

Homeomorphic Embedding Order

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

From the DPs we obtained the following set of size-change graphs:

  • REN(x, y, apply(t, s)) → REN(x, y, s) (allowed arguments on rhs = {1, 2, 3})
    The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3

  • REN(x, y, apply(t, s)) → REN(x, y, t) (allowed arguments on rhs = {1, 2, 3})
    The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3

  • REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)) (allowed arguments on rhs = {1, 2, 3})
    The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3

  • REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t) (allowed arguments on rhs = {1, 2, 3})
    The graph contains the following edges 3 > 3

We oriented the following set of usable rules [AAECC05,FROCOS05].


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)))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')

(10) TRUE