Termination Proof using AProVE

Term Rewriting System R:
[Y, X, N, L, M]
le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

LE(s(X), s(Y)) -> LE(X, Y)
APP(cons(N, L), Y) -> APP(L, Y)
LOW(N, cons(M, L)) -> IFLOW(le(M, N), N, cons(M, L))
LOW(N, cons(M, L)) -> LE(M, N)
IFLOW(true, N, cons(M, L)) -> LOW(N, L)
IFLOW(false, N, cons(M, L)) -> LOW(N, L)
HIGH(N, cons(M, L)) -> IFHIGH(le(M, N), N, cons(M, L))
HIGH(N, cons(M, L)) -> LE(M, N)
IFHIGH(true, N, cons(M, L)) -> HIGH(N, L)
IFHIGH(false, N, cons(M, L)) -> HIGH(N, L)
QUICKSORT(cons(N, L)) -> APP(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))
QUICKSORT(cons(N, L)) -> QUICKSORT(low(N, L))
QUICKSORT(cons(N, L)) -> LOW(N, L)
QUICKSORT(cons(N, L)) -> QUICKSORT(high(N, L))
QUICKSORT(cons(N, L)) -> HIGH(N, L)

Furthermore, R contains five SCCs.

     ↳DPs

       →DP Problem 1

         ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pair:

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

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

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

     ↳DPs

       →DP Problem 1

         ↳AFS

           →DP Problem 6

             ↳Dependency Graph

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pair:

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

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

         ↳Nar

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pair:

APP(cons(N, L), Y) -> APP(L, Y)

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

The following dependency pair can be strictly oriented:

APP(cons(N, L), Y) -> APP(L, Y)

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

APP(x₁, x₂) -> APP(x₁, x₂)
cons(x₁, x₂) -> cons(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

           →DP Problem 7

             ↳Dependency Graph

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pair:

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Narrowing Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(false, N, cons(M, L)) -> LOW(N, L)
IFLOW(true, N, cons(M, L)) -> LOW(N, L)
LOW(N, cons(M, L)) -> IFLOW(le(M, N), N, cons(M, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

LOW(N, cons(M, L)) -> IFLOW(le(M, N), N, cons(M, L))

three new Dependency Pairs are created:

LOW(N', cons(0, L)) -> IFLOW(true, N', cons(0, L))
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
IFLOW(true, N, cons(M, L)) -> LOW(N, L)
LOW(N', cons(0, L)) -> IFLOW(true, N', cons(0, L))
IFLOW(false, N, cons(M, L)) -> LOW(N, L)

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

IFLOW(true, N, cons(M, L)) -> LOW(N, L)

two new Dependency Pairs are created:

IFLOW(true, N', cons(0, L'')) -> LOW(N', L'')
IFLOW(true, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 9

                 ↳Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(true, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
IFLOW(true, N', cons(0, L'')) -> LOW(N', L'')
LOW(N', cons(0, L)) -> IFLOW(true, N', cons(0, L))
IFLOW(false, N, cons(M, L)) -> LOW(N, L)
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

IFLOW(false, N, cons(M, L)) -> LOW(N, L)

two new Dependency Pairs are created:

IFLOW(false, 0, cons(s(X'''), L'')) -> LOW(0, L'')
IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 10

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
IFLOW(false, 0, cons(s(X'''), L'')) -> LOW(0, L'')
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
IFLOW(true, N', cons(0, L'')) -> LOW(N', L'')
LOW(N', cons(0, L)) -> IFLOW(true, N', cons(0, L))
IFLOW(true, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

IFLOW(true, N', cons(0, L'')) -> LOW(N', L'')

three new Dependency Pairs are created:

IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 11

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(true, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
IFLOW(false, 0, cons(s(X'''), L'')) -> LOW(0, L'')
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N', cons(0, L)) -> IFLOW(true, N', cons(0, L))
IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

LOW(N', cons(0, L)) -> IFLOW(true, N', cons(0, L))

three new Dependency Pairs are created:

LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 12

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(false, 0, cons(s(X'''), L'')) -> LOW(0, L'')
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
IFLOW(true, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

IFLOW(true, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

three new Dependency Pairs are created:

IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 13

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

IFLOW(false, 0, cons(s(X'''), L'')) -> LOW(0, L'')

three new Dependency Pairs are created:

IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 14

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

LOW(0, cons(s(X'), L)) -> IFLOW(false, 0, cons(s(X'), L))

three new Dependency Pairs are created:

LOW(0, cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(false, 0, cons(s(X''), cons(s(X''''''), L''''')))
LOW(0, cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(0, L'''''''''))))
LOW(0, cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 15

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))
LOW(0, cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
LOW(0, cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(false, 0, cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

IFLOW(false, s(Y'''), cons(s(X'''), L'')) -> LOW(s(Y'''), L'')

three new Dependency Pairs are created:

IFLOW(false, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 8

             ↳Inst

...

               →DP Problem 16

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Remaining

       →DP Problem 5

         ↳Remaining

Dependency Pairs:

IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(false, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))
LOW(0, cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
LOW(0, cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(false, 0, cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:

innermost

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

LOW(s(Y'), cons(s(X'), L)) -> IFLOW(le(X', Y'), s(Y'), cons(s(X'), L))

three new Dependency Pairs are created:

LOW(s(Y''), cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(s(X''''''), L''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(0, L'''''''''))))
LOW(s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

The following remains to be proven:

Dependency Pairs:
IFLOW(false, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))
LOW(0, cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
LOW(0, cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(false, 0, cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
LOW(s(Y''), cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost
Dependency Pairs:
IFHIGH(false, N, cons(M, L)) -> HIGH(N, L)
IFHIGH(true, N, cons(M, L)) -> HIGH(N, L)
HIGH(N, cons(M, L)) -> IFHIGH(le(M, N), N, cons(M, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost
Dependency Pairs:
QUICKSORT(cons(N, L)) -> QUICKSORT(high(N, L))
QUICKSORT(cons(N, L)) -> QUICKSORT(low(N, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

The following remains to be proven:

Dependency Pairs:
IFLOW(false, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))
LOW(0, cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
LOW(0, cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(false, 0, cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
LOW(s(Y''), cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost
Dependency Pairs:
IFHIGH(false, N, cons(M, L)) -> HIGH(N, L)
IFHIGH(true, N, cons(M, L)) -> HIGH(N, L)
HIGH(N, cons(M, L)) -> IFHIGH(le(M, N), N, cons(M, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost
Dependency Pairs:
QUICKSORT(cons(N, L)) -> QUICKSORT(high(N, L))
QUICKSORT(cons(N, L)) -> QUICKSORT(low(N, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

The following remains to be proven:

Dependency Pairs:
IFLOW(false, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(0, cons(0, cons(s(X'''''''), L''''''')))
LOW(0, cons(s(X''), cons(0, cons(s(X'''''''''), L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(s(X'''''''''), L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(0, cons(0, cons(0, L''''''')))
LOW(0, cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(false, 0, cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(false, 0, cons(s(X'''), cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(false, 0, cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, 0, cons(0, cons(s(X'''), L'''))) -> LOW(0, cons(s(X'''), L'''))
LOW(0, cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, 0, cons(0, cons(s(X'''''), L''''')))
IFLOW(true, N''', cons(0, cons(0, L'''))) -> LOW(N''', cons(0, L'''))
LOW(N'', cons(0, cons(0, L'''''))) -> IFLOW(true, N'', cons(0, cons(0, L''''')))
IFLOW(true, s(Y''''), cons(s(X'''), cons(0, cons(0, L''''''')))) -> LOW(s(Y''''), cons(0, cons(0, L''''''')))
LOW(s(Y''), cons(s(X''), cons(0, cons(0, L''''''''')))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(0, cons(0, L'''''''''))))
IFLOW(true, s(Y''''), cons(s(X'''), cons(s(X'''), L'''))) -> LOW(s(Y''''), cons(s(X'''), L'''))
LOW(s(Y''), cons(s(X''), cons(s(X''''''), L'''''))) -> IFLOW(le(X'', Y''), s(Y''), cons(s(X''), cons(s(X''''''), L''''')))
IFLOW(true, s(Y'''), cons(0, cons(s(X'''), L'''))) -> LOW(s(Y'''), cons(s(X'''), L'''))
LOW(s(Y'''''), cons(0, cons(s(X'''''), L'''''))) -> IFLOW(true, s(Y'''''), cons(0, cons(s(X'''''), L''''')))
IFLOW(false, s(Y''''), cons(s(X'''), cons(0, cons(s(X'''''''), L''''''')))) -> LOW(s(Y''''), cons(0, cons(s(X'''''''), L''''''')))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost
Dependency Pairs:
IFHIGH(false, N, cons(M, L)) -> HIGH(N, L)
IFHIGH(true, N, cons(M, L)) -> HIGH(N, L)
HIGH(N, cons(M, L)) -> IFHIGH(le(M, N), N, cons(M, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost
Dependency Pairs:
QUICKSORT(cons(N, L)) -> QUICKSORT(high(N, L))
QUICKSORT(cons(N, L)) -> QUICKSORT(low(N, L))

Rules:

le(0, Y) -> true
le(s(X), 0) -> false
le(s(X), s(Y)) -> le(X, Y)
app(nil, Y) -> Y
app(cons(N, L), Y) -> cons(N, app(L, Y))
low(N, nil) -> nil
low(N, cons(M, L)) -> iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) -> cons(M, low(N, L))
iflow(false, N, cons(M, L)) -> low(N, L)
high(N, nil) -> nil
high(N, cons(M, L)) -> ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) -> high(N, L)
ifhigh(false, N, cons(M, L)) -> cons(M, high(N, L))
quicksort(nil) -> nil
quicksort(cons(N, L)) -> app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Strategy:
innermost

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