Termination Proof using AProVE

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.

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

     ↳DPs

       →DP Problem 1

         ↳Polynomial Ordering

       →DP Problem 2

         ↳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

The following dependency pair can be strictly oriented:

EQ(var(l), var(l')) -> EQ(l, l')

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(apply(x₁, x₂)) = x₁ + x₂

POL(EQ(x₁, x₂)) = x₁

POL(var(x₁)) = 1 + x₁

POL(cons(x₁, x₂)) = x₁ + x₂

POL(lambda(x₁, x₂)) = x₁ + x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

           →DP Problem 3

             ↳Polynomial Ordering

       →DP Problem 2

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

The following dependency pairs can be strictly oriented:

EQ(cons(t, l), cons(t', l')) -> EQ(l, l')
EQ(cons(t, l), cons(t', l')) -> EQ(t, t')

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(apply(x₁, x₂)) = x₁ + x₂

POL(EQ(x₁, x₂)) = x₁

POL(cons(x₁, x₂)) = 1 + x₁ + x₂

POL(lambda(x₁, x₂)) = x₁ + x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

           →DP Problem 3

             ↳Polo

...

               →DP Problem 4

                 ↳Polynomial Ordering

       →DP Problem 2

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

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:

EQ(lambda(x, t), lambda(x', t')) -> EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) -> EQ(x, x')

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(apply(x₁, x₂)) = x₁ + x₂

POL(EQ(x₁, x₂)) = x₁

POL(lambda(x₁, x₂)) = 1 + x₁ + x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

           →DP Problem 3

             ↳Polo

...

               →DP Problem 5

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Polo

Dependency Pairs:

EQ(apply(t, s), apply(t', s')) -> EQ(s, s')
EQ(apply(t, s), apply(t', s')) -> 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

The following dependency pairs can be strictly oriented:

EQ(apply(t, s), apply(t', s')) -> EQ(s, s')
EQ(apply(t, s), apply(t', s')) -> EQ(t, t')

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(apply(x₁, x₂)) = 1 + x₁ + x₂

POL(EQ(x₁, x₂)) = x₁

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

           →DP Problem 3

             ↳Polo

...

               →DP Problem 6

                 ↳Dependency Graph

       →DP Problem 2

         ↳Polo

Dependency Pair:

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

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polynomial Ordering

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:

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

Additionally, the following usable rules for innermost can be oriented:

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')
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'))
and(true, y) -> y
and(false, y) -> false

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(REN(x₁, x₂, x₃)) = x₃

POL(and(x₁, x₂)) = x₂

POL(if(x₁, x₂, x₃)) = 0

POL(apply(x₁, x₂)) = 1 + x₁ + x₂

POL(var(x₁)) = 0

POL(eq(x₁, x₂)) = 0

POL(cons(x₁, x₂)) = 0

POL(false) = 0

POL(lambda(x₁, x₂)) = x₂

POL(nil) = 0

POL(true) = 0

POL(ren(x₁, x₂, x₃)) = x₃

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

           →DP Problem 7

             ↳Polynomial Ordering

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

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:

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

Additionally, the following usable rules for innermost can be oriented:

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')
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'))
and(true, y) -> y
and(false, y) -> false

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(REN(x₁, x₂, x₃)) = x₃

POL(and(x₁, x₂)) = x₂

POL(if(x₁, x₂, x₃)) = 0

POL(apply(x₁, x₂)) = 0

POL(var(x₁)) = 0

POL(eq(x₁, x₂)) = 0

POL(cons(x₁, x₂)) = 0

POL(false) = 0

POL(lambda(x₁, x₂)) = 1 + x₂

POL(nil) = 0

POL(true) = 0

POL(ren(x₁, x₂, x₃)) = x₃

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

           →DP Problem 7

             ↳Polo

...

               →DP Problem 8

                 ↳Dependency Graph

Dependency Pair:

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

Using the Dependency Graph resulted in no new DP problems.

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

POL(apply(x₁, x₂))	= x₁ + x₂
POL(EQ(x₁, x₂))	= x₁
POL(var(x₁))	= 1 + x₁
POL(cons(x₁, x₂))	= x₁ + x₂
POL(lambda(x₁, x₂))	= x₁ + x₂

POL(apply(x₁, x₂))	= 1 + x₁ + x₂
POL(EQ(x₁, x₂))	= x₁

POL(REN(x₁, x₂, x₃))	= x₃
POL(and(x₁, x₂))	= x₂
POL(if(x₁, x₂, x₃))	= 0
POL(apply(x₁, x₂))	= 1 + x₁ + x₂
POL(var(x₁))	= 0
POL(eq(x₁, x₂))	= 0
POL(cons(x₁, x₂))	= 0
POL(false)	= 0
POL(lambda(x₁, x₂))	= x₂
POL(nil)	= 0
POL(true)	= 0
POL(ren(x₁, x₂, x₃))	= x₃