Termination Proof using AProVE

Term Rewriting System R:
[X, Y, N, M, Z]
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f₃(split(N, X), N, X)
f₃(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

LT(s(X), s(Y)) -> LT(X, Y)
APPEND(add(N, X), Y) -> APPEND(X, Y)
SPLIT(N, add(M, Y)) -> F₁(split(N, Y), N, M, Y)
SPLIT(N, add(M, Y)) -> SPLIT(N, Y)
F₁(pair(X, Z), N, M, Y) -> F₂(lt(N, M), N, M, Y, X, Z)
F₁(pair(X, Z), N, M, Y) -> LT(N, M)
QSORT(add(N, X)) -> F₃(split(N, X), N, X)
QSORT(add(N, X)) -> SPLIT(N, X)
F₃(pair(Y, Z), N, X) -> APPEND(qsort(Y), add(X, qsort(Z)))
F₃(pair(Y, Z), N, X) -> QSORT(Y)
F₃(pair(Y, Z), N, X) -> QSORT(Z)

Furthermore, R contains four SCCs.

     ↳DPs

       →DP Problem 1

         ↳Usable Rules (Innermost)

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

Dependency Pair:

LT(s(X), s(Y)) -> LT(X, Y)

Rules:

lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f₃(split(N, X), N, X)
f₃(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

           →DP Problem 5

             ↳Size-Change Principle

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

Dependency Pair:

LT(s(X), s(Y)) -> LT(X, Y)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

LT(s(X), s(Y)) -> LT(X, Y)

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1
2	>	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	>	1
2	>	2

D_P: empty set
Oriented Rules: none

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

trivial

with Argument Filtering System:

s(x₁) -> s(x₁)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳Usable Rules (Innermost)

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

Dependency Pair:

APPEND(add(N, X), Y) -> APPEND(X, Y)

Rules:

lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f₃(split(N, X), N, X)
f₃(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

           →DP Problem 6

             ↳Size-Change Principle

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

Dependency Pair:

APPEND(add(N, X), Y) -> APPEND(X, Y)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

APPEND(add(N, X), Y) -> APPEND(X, Y)

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1
2	=	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	>	1
2	=	2

D_P: empty set
Oriented Rules: none

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

trivial

with Argument Filtering System:

add(x₁, x₂) -> add(x₁, x₂)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳Usable Rules (Innermost)

       →DP Problem 4

         ↳UsableRules

Dependency Pair:

SPLIT(N, add(M, Y)) -> SPLIT(N, Y)

Rules:

lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f₃(split(N, X), N, X)
f₃(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

           →DP Problem 7

             ↳Size-Change Principle

       →DP Problem 4

         ↳UsableRules

Dependency Pair:

SPLIT(N, add(M, Y)) -> SPLIT(N, Y)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

SPLIT(N, add(M, Y)) -> SPLIT(N, Y)

and get the following Size-Change Graph(s):

{1}	,	{1}
1	=	1
2	>	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	=	1
2	>	2

D_P: empty set
Oriented Rules: none

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

trivial

with Argument Filtering System:

add(x₁, x₂) -> add(x₁, x₂)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳Usable Rules (Innermost)

Dependency Pairs:

F₃(pair(Y, Z), N, X) -> QSORT(Z)
F₃(pair(Y, Z), N, X) -> QSORT(Y)
QSORT(add(N, X)) -> F₃(split(N, X), N, X)

Rules:

lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f₃(split(N, X), N, X)
f₃(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 8

             ↳Negative Polynomial Order

Dependency Pairs:

F₃(pair(Y, Z), N, X) -> QSORT(Z)
F₃(pair(Y, Z), N, X) -> QSORT(Y)
QSORT(add(N, X)) -> F₃(split(N, X), N, X)

Rules:

f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)

Strategy:

innermost

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

F₃(pair(Y, Z), N, X) -> QSORT(Z)
F₃(pair(Y, Z), N, X) -> QSORT(Y)

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

f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)

Used ordering:
Polynomial Order with Interpretation:

POL( F₃(x₁, ..., x₃) ) = x₁

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

POL( QSORT(x₁) ) = x₁

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

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

POL( f₂(x₁, ..., x₆) ) = x₁ + x₅ + x₆ + 1

POL( false ) = 1

POL( true ) = 1

POL( lt(x₁, x₂) ) = 1

POL( nil ) = 0

POL( f₁(x₁, ..., x₄) ) = x₁ + 1

This results in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 8

             ↳Neg POLO

...

               →DP Problem 9

                 ↳Dependency Graph

Dependency Pair:

QSORT(add(N, X)) -> F₃(split(N, X), N, X)

Rules:

f₂(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
f₂(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f₁(split(N, Y), N, M, Y)
f₁(pair(X, Z), N, M, Y) -> f₂(lt(N, M), N, M, Y, X, Z)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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