Term Rewriting System R:
[y, t, l, t', l', s, x, s', x', k, z]
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)))

Innermost Termination of R to be shown. 



   R
     ↳Dependency Pair Analysis



R contains the following Dependency Pairs:

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)

Furthermore, R contains two SCCs. 


   R
     ↳DPs
       →DP Problem 1
         ↳Usable Rules (Innermost)
       →DP Problem 2
         ↳Neg POLO


Dependency Pairs:

EQ(lambda(x, t), lambda(x', t')) -> EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) -> EQ(x, x')
EQ(apply(t, s), apply(t', s')) -> EQ(s, s')
EQ(apply(t, s), apply(t', s')) -> EQ(t, t')
EQ(var(l), var(l')) -> EQ(l, l')
EQ(cons(t, l), cons(t', l')) -> EQ(l, l')
EQ(cons(t, l), cons(t', l')) -> EQ(t, t')


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


Strategy:

innermost




As we are in the innermost case, we can delete all 20 non-usable-rules.


   R
     ↳DPs
       →DP Problem 1
         ↳UsableRules
           →DP Problem 3
             ↳Size-Change Principle
       →DP Problem 2
         ↳Neg POLO


Dependency Pairs:

EQ(lambda(x, t), lambda(x', t')) -> EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) -> EQ(x, x')
EQ(apply(t, s), apply(t', s')) -> EQ(s, s')
EQ(apply(t, s), apply(t', s')) -> EQ(t, t')
EQ(var(l), var(l')) -> EQ(l, l')
EQ(cons(t, l), cons(t', l')) -> EQ(l, l')
EQ(cons(t, l), cons(t', l')) -> EQ(t, t')


Rule:

none


Strategy:

innermost




We number the DPs as follows:
  1. EQ(lambda(x, t), lambda(x', t')) -> EQ(t, t')
  2. EQ(lambda(x, t), lambda(x', t')) -> EQ(x, x')
  3. EQ(apply(t, s), apply(t', s')) -> EQ(s, s')
  4. EQ(apply(t, s), apply(t', s')) -> EQ(t, t')
  5. EQ(var(l), var(l')) -> EQ(l, l')
  6. EQ(cons(t, l), cons(t', l')) -> EQ(l, l')
  7. EQ(cons(t, l), cons(t', l')) -> EQ(t, t')
and get the following Size-Change Graph(s):
{1, 2, 3, 4, 5, 6, 7} , {1, 2, 3, 4, 5, 6, 7}
1>1
2>2

which lead(s) to this/these maximal multigraph(s):
{1, 2, 3, 4, 5, 6, 7} , {1, 2, 3, 4, 5, 6, 7}
1>1
2>2

DP: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.
trivial

with Argument Filtering System:
apply(x1, x2) -> apply(x1, x2)
var(x1) -> var(x1)
cons(x1, x2) -> cons(x1, x2)
lambda(x1, x2) -> lambda(x1, x2)

We obtain no new DP problems. 


   R
     ↳DPs
       →DP Problem 1
         ↳UsableRules
       →DP Problem 2
         ↳Negative Polynomial Order


Dependency Pairs:

REN(x, y, lambda(z, t)) -> REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), 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, apply(t, s)) -> REN(x, y, s)
REN(x, y, apply(t, s)) -> REN(x, y, t)


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


Strategy:

innermost




The following Dependency Pairs can be strictly oriented using the given order.

REN(x, y, lambda(z, t)) -> REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(x, y, lambda(z, t)) -> REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))


Moreover, the following usable rules (regarding the implicit AFS) are oriented.

eq(var(l), apply(t, s)) -> false
eq(var(l), var(l')) -> eq(l, l')
eq(apply(t, s), apply(t', s')) -> and(eq(t, t'), eq(s, s'))
eq(lambda(x, t), apply(t, s)) -> false
eq(cons(t, l), nil) -> false
eq(var(l), lambda(x, t)) -> false
ren(x, y, apply(t, s)) -> apply(ren(x, y, t), ren(x, y, s))
ren(var(l), var(k), var(l')) -> if(eq(l, l'), var(k), var(l'))
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)))
eq(apply(t, s), var(l)) -> false
eq(nil, nil) -> true
eq(lambda(x, t), lambda(x', t')) -> and(eq(x, x'), eq(t, t'))
and(true, y) -> y
and(false, y) -> false
eq(cons(t, l), cons(t', l')) -> and(eq(t, t'), eq(l, l'))
if(false, var(k), var(l')) -> var(l')
eq(apply(t, s), lambda(x, t)) -> false
if(true, var(k), var(l')) -> var(k)
eq(nil, cons(t, l)) -> false
eq(lambda(x, t), var(l)) -> false


Used ordering:
Polynomial Order with Interpretation:

POL( REN(x1, ..., x3) ) = x3

POL( lambda(x1, x2) ) = x2 + 1

POL( ren(x1, ..., x3) ) = x3

POL( apply(x1, x2) ) = x1 + x2

POL( eq(x1, x2) ) = 0

POL( false ) = 0

POL( and(x1, x2) ) = x2

POL( var(x1) ) = 0

POL( if(x1, ..., x3) ) = 0

POL( true ) = 0


This results in one new DP problem. 


   R
     ↳DPs
       →DP Problem 1
         ↳UsableRules
       →DP Problem 2
         ↳Neg POLO
           →DP Problem 4
             ↳Usable Rules (Innermost)


Dependency Pairs:

REN(x, y, apply(t, s)) -> REN(x, y, s)
REN(x, y, apply(t, s)) -> REN(x, y, t)


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


Strategy:

innermost




As we are in the innermost case, we can delete all 20 non-usable-rules.


   R
     ↳DPs
       →DP Problem 1
         ↳UsableRules
       →DP Problem 2
         ↳Neg POLO
           →DP Problem 4
             ↳UsableRules
             ...
               →DP Problem 5
                 ↳Size-Change Principle


Dependency Pairs:

REN(x, y, apply(t, s)) -> REN(x, y, s)
REN(x, y, apply(t, s)) -> REN(x, y, t)


Rule:

none


Strategy:

innermost




We number the DPs as follows:
  1. REN(x, y, apply(t, s)) -> REN(x, y, s)
  2. REN(x, y, apply(t, s)) -> REN(x, y, t)
and get the following Size-Change Graph(s):
{1, 2} , {1, 2}
1=1
2=2
3>3

which lead(s) to this/these maximal multigraph(s):
{1, 2} , {1, 2}
1=1
2=2
3>3

DP: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.
trivial

with Argument Filtering System:
apply(x1, x2) -> apply(x1, x2)

We obtain no new DP problems.

Innermost Termination of R successfully shown.
Duration:
0:03 minutes