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

         ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

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

The following dependency pair can be strictly oriented:

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

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

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

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

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

LT(x₁, x₂) -> LT(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳AFS

           →DP Problem 5

             ↳Dependency Graph

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

Dependency Pair:

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

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳Argument Filtering and Ordering

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

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

The following dependency pair can be strictly oriented:

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

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

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

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

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

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

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

           →DP Problem 6

             ↳Dependency Graph

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

Dependency Pair:

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

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Argument Filtering and Ordering

       →DP Problem 4

         ↳AFS

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

The following dependency pair can be strictly oriented:

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

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

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

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

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

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

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

           →DP Problem 7

             ↳Dependency Graph

       →DP Problem 4

         ↳AFS

Dependency Pair:

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

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Argument Filtering and Ordering

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

The following dependency pair can be strictly oriented:

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

The following usable rules for innermost can be oriented:

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)
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)

Used ordering: Polynomial ordering with Polynomial interpretation:

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

POL(0) = 0

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

POL(false) = 0

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

POL(nil) = 0

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

POL(true) = 0

POL(s(x₁)) = x₁

POL(QSORT(x₁)) = x₁

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

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

F₃(x₁, x₂, x₃) -> x₁
pair(x₁, x₂) -> pair(x₁, x₂)
QSORT(x₁) -> QSORT(x₁)
add(x₁, x₂) -> add(x₂)
split(x₁, x₂) -> x₂
f₁(x₁, x₂, x₃, x₄) -> f₁(x₁)
f₂(x₁, x₂, x₃, x₄, x₅, x₆) -> f₂(x₅, x₆)
lt(x₁, x₂) -> lt(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

           →DP Problem 8

             ↳Dependency Graph

Dependency Pairs:

F₃(pair(Y, Z), N, X) -> QSORT(Z)
F₃(pair(Y, Z), N, X) -> QSORT(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

Using the Dependency Graph resulted in no new DP problems.

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

POL(LT(x₁, x₂))	= x₁ + x₂
POL(s(x₁))	= 1 + x₁

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

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

POL(f_1(x₁))	= 1 + x₁
POL(0)	= 0
POL(pair(x₁, x₂))	= x₁ + x₂
POL(false)	= 0
POL(f_2(x₁, x₂))	= 1 + x₁ + x₂
POL(nil)	= 0
POL(lt(x₁, x₂))	= x₁ + x₂
POL(true)	= 0
POL(s(x₁))	= x₁
POL(QSORT(x₁))	= x₁
POL(add(x₁))	= 1 + x₁