Termination Proof using AProVE

Term Rewriting System R:
[x, y, z, u]
f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

F(j(x, y), y) -> G(f(x, k(y)))
F(j(x, y), y) -> F(x, k(y))
F(j(x, y), y) -> K(y)
F(x, h1(y, z)) -> H2(0, x, h1(y, z))
G(h2(x, y, h1(z, u))) -> H2(s(x), y, h1(z, u))
H2(x, j(y, h1(z, u)), h1(z, u)) -> H2(s(x), y, h1(s(z), u))

Furthermore, R contains two SCCs.

     ↳DPs

       →DP Problem 1

         ↳Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

Dependency Pair:

H2(x, j(y, h1(z, u)), h1(z, u)) -> H2(s(x), y, h1(s(z), u))

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

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

H2(x, j(y, h1(z, u)), h1(z, u)) -> H2(s(x), y, h1(s(z), u))

one new Dependency Pair is created:

H2(s(x''), j(y'', h1(s(z''), u'')), h1(s(z''), u'')) -> H2(s(s(x'')), y'', h1(s(s(z'')), u''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Inst

           →DP Problem 3

             ↳Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

Dependency Pair:

H2(s(x''), j(y'', h1(s(z''), u'')), h1(s(z''), u'')) -> H2(s(s(x'')), y'', h1(s(s(z'')), u''))

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

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

H2(s(x''), j(y'', h1(s(z''), u'')), h1(s(z''), u'')) -> H2(s(s(x'')), y'', h1(s(s(z'')), u''))

one new Dependency Pair is created:

H2(s(s(x'''')), j(y'''', h1(s(s(z'''')), u'''')), h1(s(s(z'''')), u'''')) -> H2(s(s(s(x''''))), y'''', h1(s(s(s(z''''))), u''''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Inst

           →DP Problem 3

             ↳Inst

...

               →DP Problem 4

                 ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳FwdInst

Dependency Pair:

H2(s(s(x'''')), j(y'''', h1(s(s(z'''')), u'''')), h1(s(s(z'''')), u'''')) -> H2(s(s(s(x''''))), y'''', h1(s(s(s(z''''))), u''''))

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

The following dependency pair can be strictly oriented:

H2(s(s(x'''')), j(y'''', h1(s(s(z'''')), u'''')), h1(s(s(z'''')), u'''')) -> H2(s(s(s(x''''))), y'''', h1(s(s(s(z''''))), u''''))

There are no usable rules for innermost that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:

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

POL(s(x₁)) = x₁

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

POL(H2(x₁, x₂, x₃)) = 1 + x₁ + x₂ + x₃

resulting in one new DP problem.
Used Argument Filtering System:

H2(x₁, x₂, x₃) -> H2(x₁, x₂, x₃)
s(x₁) -> s(x₁)
j(x₁, x₂) -> j(x₁, x₂)
h1(x₁, x₂) -> h1(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳Inst

           →DP Problem 3

             ↳Inst

...

               →DP Problem 5

                 ↳Dependency Graph

       →DP Problem 2

         ↳FwdInst

Dependency Pair:

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Inst

       →DP Problem 2

         ↳Forward Instantiation Transformation

Dependency Pair:

F(j(x, y), y) -> F(x, k(y))

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

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

F(j(x, y), y) -> F(x, k(y))

one new Dependency Pair is created:

F(j(j(x'', y'''), y0), y0) -> F(j(x'', y'''), k(y0))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Inst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 6

             ↳Forward Instantiation Transformation

Dependency Pair:

F(j(j(x'', y'''), y0), y0) -> F(j(x'', y'''), k(y0))

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

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

F(j(j(x'', y'''), y0), y0) -> F(j(x'', y'''), k(y0))

one new Dependency Pair is created:

F(j(j(j(x'''', y''''''), y'''''), y00), y00) -> F(j(j(x'''', y''''''), y'''''), k(y00))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Inst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 6

             ↳FwdInst

...

               →DP Problem 7

                 ↳Argument Filtering and Ordering

Dependency Pair:

F(j(j(j(x'''', y''''''), y'''''), y00), y00) -> F(j(j(x'''', y''''''), y'''''), k(y00))

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

The following dependency pair can be strictly oriented:

F(j(j(j(x'''', y''''''), y'''''), y00), y00) -> F(j(j(x'''', y''''''), y'''''), k(y00))

The following usable rules for innermost can be oriented:

k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(0) = 0

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

POL(h(x₁)) = x₁

POL(s(x₁)) = x₁

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

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

POL(k(x₁)) = x₁

resulting in one new DP problem.
Used Argument Filtering System:

F(x₁, x₂) -> F(x₁, x₂)
j(x₁, x₂) -> j(x₁, x₂)
k(x₁) -> k(x₁)
h(x₁) -> h(x₁)
h1(x₁, x₂) -> h1(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳Inst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 6

             ↳FwdInst

...

               →DP Problem 8

                 ↳Dependency Graph

Dependency Pair:

Rules:

f(j(x, y), y) -> g(f(x, k(y)))
f(x, h1(y, z)) -> h2(0, x, h1(y, z))
g(h2(x, y, h1(z, u))) -> h2(s(x), y, h1(z, u))
h2(x, j(y, h1(z, u)), h1(z, u)) -> h2(s(x), y, h1(s(z), u))
i(f(x, h(y))) -> y
i(h2(s(x), y, h1(x, z))) -> z
k(h(x)) -> h1(0, x)
k(h1(x, y)) -> h1(s(x), y)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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

POL(h1(x₁, x₂))	= 1 + x₁ + x₂
POL(s(x₁))	= x₁
POL(j(x₁, x₂))	= x₁ + x₂
POL(H2(x₁, x₂, x₃))	= 1 + x₁ + x₂ + x₃

POL(0)	= 0
POL(h1(x₁, x₂))	= x₁ + x₂
POL(h(x₁))	= x₁
POL(s(x₁))	= x₁
POL(j(x₁, x₂))	= 1 + x₁ + x₂
POL(F(x₁, x₂))	= 1 + x₁ + x₂
POL(k(x₁))	= x₁