Termination Proof using AProVE

Term Rewriting System R:
[X, Y, L]
rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

REV1(X, cons(Y, L)) -> REV1(Y, L)
REV(cons(X, L)) -> REV1(X, L)
REV(cons(X, L)) -> REV2(X, L)
REV2(X, cons(Y, L)) -> REV(cons(X, rev(rev2(Y, L))))
REV2(X, cons(Y, L)) -> REV(rev2(Y, L))
REV2(X, cons(Y, L)) -> REV2(Y, L)

Furthermore, R contains two SCCs.

     ↳DPs

       →DP Problem 1

         ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pair:

REV1(X, cons(Y, L)) -> REV1(Y, L)

Rules:

rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

The following dependency pair can be strictly oriented:

REV1(X, cons(Y, L)) -> REV1(Y, L)

There are no usable rules w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

           →DP Problem 3

             ↳Dependency Graph

       →DP Problem 2

         ↳Nar

Dependency Pair:

Rules:

rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Narrowing Transformation

Dependency Pairs:

REV2(X, cons(Y, L)) -> REV2(Y, L)
REV2(X, cons(Y, L)) -> REV(rev2(Y, L))
REV2(X, cons(Y, L)) -> REV(cons(X, rev(rev2(Y, L))))
REV(cons(X, L)) -> REV2(X, L)

Rules:

rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

REV2(X, cons(Y, L)) -> REV(rev2(Y, L))

two new Dependency Pairs are created:

REV2(X, cons(Y', nil)) -> REV(nil)
REV2(X, cons(Y0, cons(Y'', L''))) -> REV(rev(cons(Y0, rev(rev2(Y'', L'')))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Nar

           →DP Problem 4

             ↳Narrowing Transformation

Dependency Pairs:

REV2(X, cons(Y0, cons(Y'', L''))) -> REV(rev(cons(Y0, rev(rev2(Y'', L'')))))
REV(cons(X, L)) -> REV2(X, L)
REV2(X, cons(Y, L)) -> REV(cons(X, rev(rev2(Y, L))))
REV2(X, cons(Y, L)) -> REV2(Y, L)

Rules:

rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

REV2(X, cons(Y0, cons(Y'', L''))) -> REV(rev(cons(Y0, rev(rev2(Y'', L'')))))

three new Dependency Pairs are created:

REV2(X, cons(Y0', cons(Y''', L'''))) -> REV(cons(rev1(Y0', rev(rev2(Y''', L'''))), rev2(Y0', rev(rev2(Y''', L''')))))
REV2(X, cons(Y0, cons(Y''', nil))) -> REV(rev(cons(Y0, rev(nil))))
REV2(X, cons(Y0, cons(Y''', cons(Y', L')))) -> REV(rev(cons(Y0, rev(rev(cons(Y''', rev(rev2(Y', L'))))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Nar

           →DP Problem 4

             ↳Nar

...

               →DP Problem 5

                 ↳Polynomial Ordering

Dependency Pairs:

REV2(X, cons(Y0, cons(Y''', cons(Y', L')))) -> REV(rev(cons(Y0, rev(rev(cons(Y''', rev(rev2(Y', L'))))))))
REV2(X, cons(Y0, cons(Y''', nil))) -> REV(rev(cons(Y0, rev(nil))))
REV2(X, cons(Y0', cons(Y''', L'''))) -> REV(cons(rev1(Y0', rev(rev2(Y''', L'''))), rev2(Y0', rev(rev2(Y''', L''')))))
REV2(X, cons(Y, L)) -> REV2(Y, L)
REV2(X, cons(Y, L)) -> REV(cons(X, rev(rev2(Y, L))))
REV(cons(X, L)) -> REV2(X, L)

Rules:

rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

The following dependency pairs can be strictly oriented:

REV2(X, cons(Y0, cons(Y''', cons(Y', L')))) -> REV(rev(cons(Y0, rev(rev(cons(Y''', rev(rev2(Y', L'))))))))
REV2(X, cons(Y0, cons(Y''', nil))) -> REV(rev(cons(Y0, rev(nil))))
REV2(X, cons(Y0', cons(Y''', L'''))) -> REV(cons(rev1(Y0', rev(rev2(Y''', L'''))), rev2(Y0', rev(rev2(Y''', L''')))))
REV2(X, cons(Y, L)) -> REV2(Y, L)
REV(cons(X, L)) -> REV2(X, L)

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))

Used ordering: Polynomial ordering with Polynomial interpretation:

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

POL(rev(x₁)) = x₁

POL(0) = 0

POL(REV(x₁)) = x₁

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

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

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

POL(nil) = 0

POL(s(x₁)) = 0

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Nar

           →DP Problem 4

             ↳Nar

...

               →DP Problem 6

                 ↳Dependency Graph

Dependency Pair:

REV2(X, cons(Y, L)) -> REV(cons(X, rev(rev2(Y, L))))

Rules:

rev1(0, nil) -> 0
rev1(s(X), nil) -> s(X)
rev1(X, cons(Y, L)) -> rev1(Y, L)
rev(nil) -> nil
rev(cons(X, L)) -> cons(rev1(X, L), rev2(X, L))
rev2(X, nil) -> nil
rev2(X, cons(Y, L)) -> rev(cons(X, rev(rev2(Y, L))))

Using the Dependency Graph resulted in no new DP problems.

Termination of R successfully shown.
Duration:
0:00 minutes

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

POL(rev2(x₁, x₂))	= x₂
POL(rev(x₁))	= x₁
POL(0)	= 0
POL(REV(x₁))	= x₁
POL(cons(x₁, x₂))	= 1 + x₂
POL(rev1(x₁, x₂))	= 0
POL(REV2(x₁, x₂))	= x₂
POL(nil)	= 0
POL(s(x₁))	= 0