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

         ↳Nar

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 w.r.t. to the AFS that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
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

         ↳Nar

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

         ↳Nar

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)

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

         ↳Nar

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

         ↳Nar

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)

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

         ↳Nar

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

         ↳Narrowing Transformation

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

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

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

two new Dependency Pairs are created:

QSORT(add(N'', nil)) -> F₃(pair(nil, nil), N'', nil)
QSORT(add(N'', add(M', Y'))) -> F₃(f₁(split(N'', Y'), N'', M', Y'), N'', add(M', Y'))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Nar

           →DP Problem 8

             ↳Instantiation Transformation

Dependency Pairs:

QSORT(add(N'', add(M', Y'))) -> F₃(f₁(split(N'', Y'), N'', M', Y'), N'', add(M', Y'))
F₃(pair(Y, Z), N, X) -> QSORT(Y)
QSORT(add(N'', nil)) -> F₃(pair(nil, nil), N'', nil)
F₃(pair(Y, Z), N, X) -> QSORT(Z)

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

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

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

two new Dependency Pairs are created:

F₃(pair(nil, nil), N', nil) -> QSORT(nil)
F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Y')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 9

                 ↳Instantiation Transformation

Dependency Pairs:

F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Y')
QSORT(add(N'', nil)) -> F₃(pair(nil, nil), N'', nil)
F₃(pair(Y, Z), N, X) -> QSORT(Z)
QSORT(add(N'', add(M', Y'))) -> F₃(f₁(split(N'', Y'), N'', M', Y'), N'', add(M', 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

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

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

two new Dependency Pairs are created:

F₃(pair(nil, nil), N', nil) -> QSORT(nil)
F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Z')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 10

                 ↳Forward Instantiation Transformation

Dependency Pairs:

F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Z')
QSORT(add(N'', add(M', Y'))) -> F₃(f₁(split(N'', Y'), N'', M', Y'), N'', add(M', Y'))
F₃(pair(Y', Z'), N', add(M''', Y''')) -> 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

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

F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Y')

one new Dependency Pair is created:

F₃(pair(add(N'''', add(M''', Y''')), Z'), N', add(M''', Y''')) -> QSORT(add(N'''', add(M''', Y''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 11

                 ↳Forward Instantiation Transformation

Dependency Pairs:

F₃(pair(add(N'''', add(M''', Y''')), Z'), N', add(M''', Y''')) -> QSORT(add(N'''', add(M''', Y''')))
QSORT(add(N'', add(M', Y'))) -> F₃(f₁(split(N'', Y'), N'', M', Y'), N'', add(M', Y'))
F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Z')

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

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

F₃(pair(Y', Z'), N', add(M''', Y''')) -> QSORT(Z')

one new Dependency Pair is created:

F₃(pair(Y', add(N'''', add(M''', Y'''))), N', add(M''', Y''')) -> QSORT(add(N'''', add(M''', Y''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 12

                 ↳Remaining Obligation(s)

The following remains to be proven:
Dependency Pairs:

F₃(pair(Y', add(N'''', add(M''', Y'''))), N', add(M''', Y''')) -> QSORT(add(N'''', add(M''', Y''')))
QSORT(add(N'', add(M', Y'))) -> F₃(f₁(split(N'', Y'), N'', M', Y'), N'', add(M', Y'))
F₃(pair(add(N'''', add(M''', Y''')), Z'), N', add(M''', Y''')) -> QSORT(add(N'''', add(M''', 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

Innermost Termination of R could not be shown.
Duration:
0:02 minutes