Termination Proof using AProVE

Term Rewriting System R:
[x, y, n, m]
eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

EQ(s(x), s(y)) -> EQ(x, y)
LE(s(x), s(y)) -> LE(x, y)
APP(add(n, x), y) -> APP(x, y)
MIN(add(n, add(m, x))) -> IF_MIN(le(n, m), add(n, add(m, x)))
MIN(add(n, add(m, x))) -> LE(n, m)
IF_MIN(true, add(n, add(m, x))) -> MIN(add(n, x))
IF_MIN(false, add(n, add(m, x))) -> MIN(add(m, x))
RM(n, add(m, x)) -> IF_RM(eq(n, m), n, add(m, x))
RM(n, add(m, x)) -> EQ(n, m)
IF_RM(true, n, add(m, x)) -> RM(n, x)
IF_RM(false, n, add(m, x)) -> RM(n, x)
MINSORT(add(n, x), y) -> IF_MINSORT(eq(n, min(add(n, x))), add(n, x), y)
MINSORT(add(n, x), y) -> EQ(n, min(add(n, x)))
MINSORT(add(n, x), y) -> MIN(add(n, x))
IF_MINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
IF_MINSORT(true, add(n, x), y) -> APP(rm(n, x), y)
IF_MINSORT(true, add(n, x), y) -> RM(n, x)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))

Furthermore, R contains six SCCs.

     ↳DPs

       →DP Problem 1

         ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

EQ(s(x), s(y)) -> EQ(x, y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

EQ(s(x), s(y)) -> EQ(x, y)

one new Dependency Pair is created:

EQ(s(s(x'')), s(s(y''))) -> EQ(s(x''), s(y''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

           →DP Problem 7

             ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

EQ(s(s(x'')), s(s(y''))) -> EQ(s(x''), s(y''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

EQ(s(s(x'')), s(s(y''))) -> EQ(s(x''), s(y''))

one new Dependency Pair is created:

EQ(s(s(s(x''''))), s(s(s(y'''')))) -> EQ(s(s(x'''')), s(s(y'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

           →DP Problem 7

             ↳FwdInst

...

               →DP Problem 8

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

EQ(s(s(s(x''''))), s(s(s(y'''')))) -> EQ(s(s(x'''')), s(s(y'''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

EQ(s(s(s(x''''))), s(s(s(y'''')))) -> EQ(s(s(x'''')), s(s(y'''')))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

           →DP Problem 7

             ↳FwdInst

...

               →DP Problem 9

                 ↳Dependency Graph

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

LE(s(x), s(y)) -> LE(x, y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

LE(s(x), s(y)) -> LE(x, y)

one new Dependency Pair is created:

LE(s(s(x'')), s(s(y''))) -> LE(s(x''), s(y''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 10

             ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

LE(s(s(x'')), s(s(y''))) -> LE(s(x''), s(y''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

LE(s(s(x'')), s(s(y''))) -> LE(s(x''), s(y''))

one new Dependency Pair is created:

LE(s(s(s(x''''))), s(s(s(y'''')))) -> LE(s(s(x'''')), s(s(y'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 10

             ↳FwdInst

...

               →DP Problem 11

                 ↳Polynomial Ordering

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

LE(s(s(s(x''''))), s(s(s(y'''')))) -> LE(s(s(x'''')), s(s(y'''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

LE(s(s(s(x''''))), s(s(s(y'''')))) -> LE(s(s(x'''')), s(s(y'''')))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 10

             ↳FwdInst

...

               →DP Problem 12

                 ↳Dependency Graph

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

APP(add(n, x), y) -> APP(x, y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

APP(add(n, x), y) -> APP(x, y)

one new Dependency Pair is created:

APP(add(n, add(n'', x'')), y'') -> APP(add(n'', x''), y'')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

           →DP Problem 13

             ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

APP(add(n, add(n'', x'')), y'') -> APP(add(n'', x''), y'')

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

APP(add(n, add(n'', x'')), y'') -> APP(add(n'', x''), y'')

one new Dependency Pair is created:

APP(add(n, add(n'''', add(n''''', x''''))), y'''') -> APP(add(n'''', add(n''''', x'''')), y'''')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

           →DP Problem 13

             ↳FwdInst

...

               →DP Problem 14

                 ↳Polynomial Ordering

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

APP(add(n, add(n'''', add(n''''', x''''))), y'''') -> APP(add(n'''', add(n''''', x'''')), y'''')

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

APP(add(n, add(n'''', add(n''''', x''''))), y'''') -> APP(add(n'''', add(n''''', x'''')), y'''')

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

           →DP Problem 13

             ↳FwdInst

...

               →DP Problem 15

                 ↳Dependency Graph

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Narrowing Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, n, add(m, x)) -> RM(n, x)
IF_RM(true, n, add(m, x)) -> RM(n, x)
RM(n, add(m, x)) -> IF_RM(eq(n, m), n, add(m, x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

RM(n, add(m, x)) -> IF_RM(eq(n, m), n, add(m, x))

four new Dependency Pairs are created:

RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))
RM(s(x''), add(s(y'), x)) -> IF_RM(eq(x'', y'), s(x''), add(s(y'), x))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Narrowing Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

RM(s(x''), add(s(y'), x)) -> IF_RM(eq(x'', y'), s(x''), add(s(y'), x))
RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
IF_RM(true, n, add(m, x)) -> RM(n, x)
RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))
IF_RM(false, n, add(m, x)) -> RM(n, x)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

RM(s(x''), add(s(y'), x)) -> IF_RM(eq(x'', y'), s(x''), add(s(y'), x))

four new Dependency Pairs are created:

RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 17

                 ↳Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
IF_RM(true, n, add(m, x)) -> RM(n, x)
RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))
IF_RM(false, n, add(m, x)) -> RM(n, x)
RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(true, n, add(m, x)) -> RM(n, x)

three new Dependency Pairs are created:

IF_RM(true, 0, add(0, x'')) -> RM(0, x'')
IF_RM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')
IF_RM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 18

                 ↳Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
IF_RM(true, 0, add(0, x'')) -> RM(0, x'')
RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))
IF_RM(false, n, add(m, x)) -> RM(n, x)
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(false, n, add(m, x)) -> RM(n, x)

five new Dependency Pairs are created:

IF_RM(false, 0, add(s(x''''), x'')) -> RM(0, x'')
IF_RM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
IF_RM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
IF_RM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')

The transformation is resulting in two new DP problems:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 19

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))
IF_RM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')

three new Dependency Pairs are created:

IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 21

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))
IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')

three new Dependency Pairs are created:

IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 23

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')

five new Dependency Pairs are created:

IF_RM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
IF_RM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
IF_RM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 25

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

RM(s(x''), add(0, x)) -> IF_RM(false, s(x''), add(0, x))

five new Dependency Pairs are created:

RM(s(x'''), add(0, add(0, x'0''))) -> IF_RM(false, s(x'''), add(0, add(0, x'0'')))
RM(s(0), add(0, add(s(0), x'''''))) -> IF_RM(false, s(0), add(0, add(s(0), x''''')))
RM(s(0), add(0, add(s(s(x'''''''')), x'''''))) -> IF_RM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
RM(s(s(x'''''''')), add(0, add(s(0), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
RM(s(s(x'''''''')), add(0, add(s(s(y'''''')), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 27

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IF_RM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
RM(s(s(x'''''''')), add(0, add(s(s(y'''''')), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IF_RM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x'''''''')), add(0, add(s(0), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
RM(s(0), add(0, add(s(s(x'''''''')), x'''''))) -> IF_RM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(0, add(s(0), x'''''))) -> IF_RM(false, s(0), add(0, add(s(0), x''''')))
IF_RM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
RM(s(x'''), add(0, add(0, x'0''))) -> IF_RM(false, s(x'''), add(0, add(0, x'0'')))
IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')

five new Dependency Pairs are created:

IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 29

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IF_RM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
RM(s(s(x'''''''')), add(0, add(s(s(y'''''')), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IF_RM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x'''''''')), add(0, add(s(0), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
RM(s(0), add(0, add(s(s(x'''''''')), x'''''))) -> IF_RM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(0, add(s(0), x'''''))) -> IF_RM(false, s(0), add(0, add(s(0), x''''')))
IF_RM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
RM(s(x'''), add(0, add(0, x'0''))) -> IF_RM(false, s(x'''), add(0, add(0, x'0'')))
IF_RM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')

five new Dependency Pairs are created:

IF_RM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 30

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IF_RM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
RM(s(s(x'''''''')), add(0, add(s(s(y'''''')), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IF_RM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x'''''''')), add(0, add(s(0), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
RM(s(0), add(0, add(s(s(x'''''''')), x'''''))) -> IF_RM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(0, add(s(0), x'''''))) -> IF_RM(false, s(0), add(0, add(s(0), x''''')))
IF_RM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
RM(s(x'''), add(0, add(0, x'0''))) -> IF_RM(false, s(x'''), add(0, add(0, x'0'')))
IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')

five new Dependency Pairs are created:

IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(false, s(s(x'''''0)), add(s(s(y'''')), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''0)), add(s(s(y'''')), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 31

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x'''''0)), add(s(s(y'''')), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))
IF_RM(false, s(s(x'''''0)), add(s(s(y'''')), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x'''''''')), add(0, add(s(0), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
RM(s(0), add(0, add(s(s(x'''''''')), x'''''))) -> IF_RM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(0, add(s(0), x'''''))) -> IF_RM(false, s(0), add(0, add(s(0), x''''')))
IF_RM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
RM(s(x'''), add(0, add(0, x'0''))) -> IF_RM(false, s(x'''), add(0, add(0, x'0'')))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
RM(s(s(x'''''''')), add(0, add(s(s(y'''''')), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_RM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
IF_RM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
IF_RM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

Additionally, the following usable rules for innermost can be oriented:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 1

POL(false) = 0

POL(true) = 0

POL(s(x₁)) = 0

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 33

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x'''''0)), add(s(s(y'''')), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))
IF_RM(false, s(s(x'''''0)), add(s(s(y'''')), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(0), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(0), x''''''')))
IF_RM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
RM(s(s(x'''''''')), add(0, add(s(0), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IF_RM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
RM(s(0), add(0, add(s(s(x'''''''')), x'''''))) -> IF_RM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IF_RM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
RM(s(0), add(0, add(s(0), x'''''))) -> IF_RM(false, s(0), add(0, add(s(0), x''''')))
RM(s(x'''), add(0, add(0, x'0''))) -> IF_RM(false, s(x'''), add(0, add(0, x'0'')))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
RM(s(s(x'''''''')), add(0, add(s(s(y'''''')), x'''''))) -> IF_RM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IF_RM(false, s(s(x'''''0)), add(s(0), add(0, add(s(s(y'''''''')), x''''''')))) -> RM(s(s(x'''''0)), add(0, add(s(s(y'''''''')), x''''''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph the DP problem was split into 2 DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 35

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_RM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))

Additionally, the following usable rules for innermost can be oriented:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 1

POL(false) = 0

POL(true) = 0

POL(s(x₁)) = x₁

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 38

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
RM(s(s(x''')), add(s(0), x)) -> IF_RM(false, s(s(x''')), add(s(0), x))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph the DP problem was split into 1 DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 40

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_RM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IF_RM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))

Additionally, the following usable rules for innermost can be oriented:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 0

POL(false) = 0

POL(true) = 0

POL(s(x₁)) = 0

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 42

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

RM(s(s(x''')), add(s(s(y'')), x)) -> IF_RM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 36

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_RM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IF_RM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(0) = 1

POL(false) = 0

POL(true) = 0

POL(s(x₁)) = x₁

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 39

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
RM(s(0), add(s(0), x)) -> IF_RM(true, s(0), add(s(0), x))
IF_RM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph the DP problem was split into 1 DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 41

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))
IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_RM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(0) = 0

POL(false) = 0

POL(s(x₁)) = 1

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 43

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

RM(s(0), add(s(s(x''')), x)) -> IF_RM(false, s(0), add(s(s(x''')), x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 20

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(true, 0, add(0, x'')) -> RM(0, x'')
RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))
IF_RM(false, 0, add(s(x''''), x'')) -> RM(0, x'')
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(true, 0, add(0, x'')) -> RM(0, x'')

two new Dependency Pairs are created:

IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
IF_RM(true, 0, add(0, add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 22

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, 0, add(s(x''''), x'')) -> RM(0, x'')
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
IF_RM(true, 0, add(0, add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

RM(0, add(0, x)) -> IF_RM(true, 0, add(0, x))

two new Dependency Pairs are created:

RM(0, add(0, add(0, x'''''))) -> IF_RM(true, 0, add(0, add(0, x''''')))
RM(0, add(0, add(s(x''''''), x'0''))) -> IF_RM(true, 0, add(0, add(s(x''''''), x'0'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 24

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(true, 0, add(0, add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
RM(0, add(0, add(s(x''''''), x'0''))) -> IF_RM(true, 0, add(0, add(s(x''''''), x'0'')))
IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IF_RM(true, 0, add(0, add(0, x''''')))
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
IF_RM(false, 0, add(s(x''''), x'')) -> RM(0, x'')

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_RM(false, 0, add(s(x''''), x'')) -> RM(0, x'')

three new Dependency Pairs are created:

IF_RM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
IF_RM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
IF_RM(false, 0, add(s(x''''), add(0, add(s(x''''''''), x'0'''')))) -> RM(0, add(0, add(s(x''''''''), x'0'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 26

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_RM(false, 0, add(s(x''''), add(0, add(s(x''''''''), x'0'''')))) -> RM(0, add(0, add(s(x''''''''), x'0'''')))
RM(0, add(0, add(s(x''''''), x'0''))) -> IF_RM(true, 0, add(0, add(s(x''''''), x'0'')))
IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IF_RM(true, 0, add(0, add(0, x''''')))
IF_RM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
IF_RM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))
IF_RM(true, 0, add(0, add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

RM(0, add(s(x''), x)) -> IF_RM(false, 0, add(s(x''), x))

three new Dependency Pairs are created:

RM(0, add(s(x'''), add(s(x'''''''), x'0''))) -> IF_RM(false, 0, add(s(x'''), add(s(x'''''''), x'0'')))
RM(0, add(s(x'''), add(0, add(0, x''''''''')))) -> IF_RM(false, 0, add(s(x'''), add(0, add(0, x'''''''''))))
RM(0, add(s(x'''), add(0, add(s(x''''''''''), x'0'''''')))) -> IF_RM(false, 0, add(s(x'''), add(0, add(s(x''''''''''), x'0''''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 28

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

RM(0, add(s(x'''), add(0, add(s(x''''''''''), x'0'''''')))) -> IF_RM(false, 0, add(s(x'''), add(0, add(s(x''''''''''), x'0''''''))))
IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IF_RM(true, 0, add(0, add(0, x''''')))
IF_RM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
RM(0, add(s(x'''), add(0, add(0, x''''''''')))) -> IF_RM(false, 0, add(s(x'''), add(0, add(0, x'''''''''))))
IF_RM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
RM(0, add(s(x'''), add(s(x'''''''), x'0''))) -> IF_RM(false, 0, add(s(x'''), add(s(x'''''''), x'0'')))
IF_RM(true, 0, add(0, add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
RM(0, add(0, add(s(x''''''), x'0''))) -> IF_RM(true, 0, add(0, add(s(x''''''), x'0'')))
IF_RM(false, 0, add(s(x''''), add(0, add(s(x''''''''), x'0'''')))) -> RM(0, add(0, add(s(x''''''''), x'0'''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_RM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
IF_RM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
IF_RM(false, 0, add(s(x''''), add(0, add(s(x''''''''), x'0'''')))) -> RM(0, add(0, add(s(x''''''''), x'0'''')))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(0) = 0

POL(false) = 0

POL(true) = 0

POL(s(x₁)) = 1

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 32

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph the DP problem was split into 1 DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 34

                 ↳Polynomial Ordering

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pairs:

RM(0, add(0, add(0, x'''''))) -> IF_RM(true, 0, add(0, add(0, x''''')))
IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_RM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_RM(x₁, x₂, x₃)) = x₃

POL(0) = 1

POL(true) = 0

POL(RM(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 37

                 ↳Dependency Graph

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

Dependency Pair:

RM(0, add(0, add(0, x'''''))) -> IF_RM(true, 0, add(0, add(0, x''''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Narrowing Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(false, add(n, add(m, x))) -> MIN(add(m, x))
IF_MIN(true, add(n, add(m, x))) -> MIN(add(n, x))
MIN(add(n, add(m, x))) -> IF_MIN(le(n, m), add(n, add(m, x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MIN(add(n, add(m, x))) -> IF_MIN(le(n, m), add(n, add(m, x)))

three new Dependency Pairs are created:

MIN(add(0, add(m', x))) -> IF_MIN(true, add(0, add(m', x)))
MIN(add(s(x''), add(0, x))) -> IF_MIN(false, add(s(x''), add(0, x)))
MIN(add(s(x''), add(s(y'), x))) -> IF_MIN(le(x'', y'), add(s(x''), add(s(y'), x)))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Narrowing Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

MIN(add(s(x''), add(s(y'), x))) -> IF_MIN(le(x'', y'), add(s(x''), add(s(y'), x)))
MIN(add(s(x''), add(0, x))) -> IF_MIN(false, add(s(x''), add(0, x)))
IF_MIN(true, add(n, add(m, x))) -> MIN(add(n, x))
MIN(add(0, add(m', x))) -> IF_MIN(true, add(0, add(m', x)))
IF_MIN(false, add(n, add(m, x))) -> MIN(add(m, x))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MIN(add(s(x''), add(s(y'), x))) -> IF_MIN(le(x'', y'), add(s(x''), add(s(y'), x)))

three new Dependency Pairs are created:

MIN(add(s(0), add(s(y''), x))) -> IF_MIN(true, add(s(0), add(s(y''), x)))
MIN(add(s(s(x''')), add(s(0), x))) -> IF_MIN(false, add(s(s(x''')), add(s(0), x)))
MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 45

                 ↳Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
MIN(add(s(s(x''')), add(s(0), x))) -> IF_MIN(false, add(s(s(x''')), add(s(0), x)))
MIN(add(s(0), add(s(y''), x))) -> IF_MIN(true, add(s(0), add(s(y''), x)))
IF_MIN(true, add(n, add(m, x))) -> MIN(add(n, x))
MIN(add(0, add(m', x))) -> IF_MIN(true, add(0, add(m', x)))
IF_MIN(false, add(n, add(m, x))) -> MIN(add(m, x))
MIN(add(s(x''), add(0, x))) -> IF_MIN(false, add(s(x''), add(0, x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MIN(true, add(n, add(m, x))) -> MIN(add(n, x))

three new Dependency Pairs are created:

IF_MIN(true, add(0, add(m', x''))) -> MIN(add(0, x''))
IF_MIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
IF_MIN(true, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(x''''')), x'))

The transformation is resulting in two new DP problems:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 46

                 ↳Forward Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(true, add(0, add(m', x''))) -> MIN(add(0, x''))
MIN(add(0, add(m', x))) -> IF_MIN(true, add(0, add(m', x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MIN(true, add(0, add(m', x''))) -> MIN(add(0, x''))

one new Dependency Pair is created:

IF_MIN(true, add(0, add(m', add(m''', x''')))) -> MIN(add(0, add(m''', x''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 48

                 ↳Forward Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(true, add(0, add(m', add(m''', x''')))) -> MIN(add(0, add(m''', x''')))
MIN(add(0, add(m', x))) -> IF_MIN(true, add(0, add(m', x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MIN(add(0, add(m', x))) -> IF_MIN(true, add(0, add(m', x)))

one new Dependency Pair is created:

MIN(add(0, add(m''', add(m''''', x''''')))) -> IF_MIN(true, add(0, add(m''', add(m''''', x'''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 51

                 ↳Polynomial Ordering

       →DP Problem 6

         ↳Nar

Dependency Pairs:

MIN(add(0, add(m''', add(m''''', x''''')))) -> IF_MIN(true, add(0, add(m''', add(m''''', x'''''))))
IF_MIN(true, add(0, add(m', add(m''', x''')))) -> MIN(add(0, add(m''', x''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_MIN(true, add(0, add(m', add(m''', x''')))) -> MIN(add(0, add(m''', x''')))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(0) = 0

POL(MIN(x₁)) = x₁

POL(true) = 0

POL(IF_MIN(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 55

                 ↳Dependency Graph

       →DP Problem 6

         ↳Nar

Dependency Pair:

MIN(add(0, add(m''', add(m''''', x''''')))) -> IF_MIN(true, add(0, add(m''', add(m''''', x'''''))))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 47

                 ↳Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(true, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(x''''')), x'))
MIN(add(s(s(x''')), add(s(0), x))) -> IF_MIN(false, add(s(s(x''')), add(s(0), x)))
IF_MIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
MIN(add(s(0), add(s(y''), x))) -> IF_MIN(true, add(s(0), add(s(y''), x)))
MIN(add(s(x''), add(0, x))) -> IF_MIN(false, add(s(x''), add(0, x)))
IF_MIN(false, add(n, add(m, x))) -> MIN(add(m, x))
MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MIN(false, add(n, add(m, x))) -> MIN(add(m, x))

three new Dependency Pairs are created:

IF_MIN(false, add(s(x''''), add(0, x''))) -> MIN(add(0, x''))
IF_MIN(false, add(s(s(x''''')), add(s(0), x''))) -> MIN(add(s(0), x''))
IF_MIN(false, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(y'''')), x'))

The transformation is resulting in two new DP problems:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 49

                 ↳Forward Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
MIN(add(s(0), add(s(y''), x))) -> IF_MIN(true, add(s(0), add(s(y''), x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))

one new Dependency Pair is created:

IF_MIN(true, add(s(0), add(s(y''''), add(s(y''''), x''')))) -> MIN(add(s(0), add(s(y''''), x''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 52

                 ↳Polynomial Ordering

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(true, add(s(0), add(s(y''''), add(s(y''''), x''')))) -> MIN(add(s(0), add(s(y''''), x''')))
MIN(add(s(0), add(s(y''), x))) -> IF_MIN(true, add(s(0), add(s(y''), x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_MIN(true, add(s(0), add(s(y''''), add(s(y''''), x''')))) -> MIN(add(s(0), add(s(y''''), x''')))

There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(0) = 0

POL(MIN(x₁)) = x₁

POL(true) = 0

POL(IF_MIN(x₁, x₂)) = x₂

POL(s(x₁)) = 1

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 56

                 ↳Dependency Graph

       →DP Problem 6

         ↳Nar

Dependency Pair:

MIN(add(s(0), add(s(y''), x))) -> IF_MIN(true, add(s(0), add(s(y''), x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 50

                 ↳Forward Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(false, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(y'''')), x'))
MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
IF_MIN(true, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(x''''')), x'))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MIN(true, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(x''''')), x'))

one new Dependency Pair is created:

IF_MIN(true, add(s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x''')))) -> MIN(add(s(s(x'''''')), add(s(s(y'''')), x''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 53

                 ↳Forward Instantiation Transformation

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(true, add(s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x''')))) -> MIN(add(s(s(x'''''')), add(s(s(y'''')), x''')))
MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
IF_MIN(false, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(y'''')), x'))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MIN(false, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(y'''')), x'))

one new Dependency Pair is created:

IF_MIN(false, add(s(s(x''''')), add(s(s(y'''''')), add(s(s(y''''')), x''')))) -> MIN(add(s(s(y'''''')), add(s(s(y''''')), x''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 54

                 ↳Polynomial Ordering

       →DP Problem 6

         ↳Nar

Dependency Pairs:

IF_MIN(false, add(s(s(x''''')), add(s(s(y'''''')), add(s(s(y''''')), x''')))) -> MIN(add(s(s(y'''''')), add(s(s(y''''')), x''')))
MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
IF_MIN(true, add(s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x''')))) -> MIN(add(s(s(x'''''')), add(s(s(y'''')), x''')))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_MIN(false, add(s(s(x''''')), add(s(s(y'''''')), add(s(s(y''''')), x''')))) -> MIN(add(s(s(y'''''')), add(s(s(y''''')), x''')))
IF_MIN(true, add(s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x''')))) -> MIN(add(s(s(x'''''')), add(s(s(y'''')), x''')))

Additionally, the following usable rules for innermost can be oriented:

le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(0) = 0

POL(false) = 0

POL(MIN(x₁)) = x₁

POL(true) = 0

POL(s(x₁)) = 0

POL(IF_MIN(x₁, x₂)) = x₂

POL(le(x₁, x₂)) = 0

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

           →DP Problem 44

             ↳Nar

...

               →DP Problem 57

                 ↳Dependency Graph

       →DP Problem 6

         ↳Nar

Dependency Pair:

MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IF_MIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Narrowing Transformation

Dependency Pairs:

IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
IF_MINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
MINSORT(add(n, x), y) -> IF_MINSORT(eq(n, min(add(n, x))), add(n, x), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MINSORT(add(n, x), y) -> IF_MINSORT(eq(n, min(add(n, x))), add(n, x), y)

two new Dependency Pairs are created:

MINSORT(add(n'', nil), y) -> IF_MINSORT(eq(n'', n''), add(n'', nil), y)
MINSORT(add(n'', add(m', x'')), y) -> IF_MINSORT(eq(n'', if_min(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Narrowing Transformation

Dependency Pairs:

MINSORT(add(n'', add(m', x'')), y) -> IF_MINSORT(eq(n'', if_min(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)
IF_MINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
MINSORT(add(n'', nil), y) -> IF_MINSORT(eq(n'', n''), add(n'', nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)

two new Dependency Pairs are created:

IF_MINSORT(true, add(n'', nil), y) -> MINSORT(app(nil, y), nil)
IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 59

                 ↳Rewriting Transformation

Dependency Pairs:

IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(app(nil, y), nil)
MINSORT(add(n'', nil), y) -> IF_MINSORT(eq(n'', n''), add(n'', nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(n'', add(m', x'')), y) -> IF_MINSORT(eq(n'', if_min(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(n'', nil), y) -> MINSORT(app(nil, y), nil)

one new Dependency Pair is created:

IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 60

                 ↳Narrowing Transformation

Dependency Pairs:

IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(n'', add(m', x'')), y) -> IF_MINSORT(eq(n'', if_min(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(n'', nil), y) -> IF_MINSORT(eq(n'', n''), add(n'', nil), y)
IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MINSORT(add(n'', nil), y) -> IF_MINSORT(eq(n'', n''), add(n'', nil), y)

two new Dependency Pairs are created:

MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 61

                 ↳Narrowing Transformation

Dependency Pairs:

IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(n'', add(m', x'')), y) -> IF_MINSORT(eq(n'', if_min(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MINSORT(add(n'', add(m', x'')), y) -> IF_MINSORT(eq(n'', if_min(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)

three new Dependency Pairs are created:

MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, if_min(true, add(0, add(m'', x'')))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), if_min(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 62

                 ↳Rewriting Transformation

Dependency Pairs:

MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), if_min(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, if_min(true, add(0, add(m'', x'')))), add(0, add(m'', x'')), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, if_min(true, add(0, add(m'', x'')))), add(0, add(m'', x'')), y)

one new Dependency Pair is created:

MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 63

                 ↳Rewriting Transformation

Dependency Pairs:

MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), if_min(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), if_min(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)

one new Dependency Pair is created:

MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 64

                 ↳Narrowing Transformation

Dependency Pairs:

MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(if_rm(eq(n'', m'), n'', add(m', x'')), y), nil)

four new Dependency Pairs are created:

IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(if_rm(true, 0, add(0, x'')), y), nil)
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(if_rm(false, 0, add(s(x'), x'')), y), nil)
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(if_rm(false, s(x'), add(0, x'')), y), nil)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 65

                 ↳Rewriting Transformation

Dependency Pairs:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(if_rm(false, s(x'), add(0, x'')), y), nil)
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(if_rm(false, 0, add(s(x'), x'')), y), nil)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(if_rm(true, 0, add(0, x'')), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(if_rm(true, 0, add(0, x'')), y), nil)

one new Dependency Pair is created:

IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 66

                 ↳Rewriting Transformation

Dependency Pairs:

IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(if_rm(false, 0, add(s(x'), x'')), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(if_rm(false, s(x'), add(0, x'')), y), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(if_rm(false, 0, add(s(x'), x'')), y), nil)

one new Dependency Pair is created:

IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(add(s(x'), rm(0, x'')), y), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 67

                 ↳Rewriting Transformation

Dependency Pairs:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(if_rm(false, s(x'), add(0, x'')), y), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(add(s(x'), rm(0, x'')), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(if_rm(false, s(x'), add(0, x'')), y), nil)

one new Dependency Pair is created:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(add(0, rm(s(x'), x'')), y), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 68

                 ↳Rewriting Transformation

Dependency Pairs:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(add(0, rm(s(x'), x'')), y), nil)
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(add(s(x'), rm(0, x'')), y), nil)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(add(s(x'), rm(0, x'')), y), nil)

one new Dependency Pair is created:

IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 69

                 ↳Rewriting Transformation

Dependency Pairs:

IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(add(0, rm(s(x'), x'')), y), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(add(0, rm(s(x'), x'')), y), nil)

one new Dependency Pair is created:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 70

                 ↳Instantiation Transformation

Dependency Pairs:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))

four new Dependency Pairs are created:

IF_MINSORT(false, add(s(x'0'), nil), y'') -> MINSORT(nil, add(s(x'0'), y''))
IF_MINSORT(false, add(s(x'''0), add(s(y''''), x''''')), y'') -> MINSORT(add(s(y''''), x'''''), add(s(x'''0), y''))
IF_MINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))
IF_MINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 71

                 ↳Forward Instantiation Transformation

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0), add(s(y''''), x''''')), y'') -> MINSORT(add(s(y''''), x'''''), add(s(x'''0), y''))
IF_MINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IF_MINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(false, add(s(x'''0), add(s(y''''), x''''')), y'') -> MINSORT(add(s(y''''), x'''''), add(s(x'''0), y''))

three new Dependency Pairs are created:

IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 72

                 ↳Forward Instantiation Transformation

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IF_MINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))

five new Dependency Pairs are created:

IF_MINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 73

                 ↳Forward Instantiation Transformation

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
IF_MINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IF_MINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

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

IF_MINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))

two new Dependency Pairs are created:

IF_MINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 74

                 ↳Polynomial Ordering

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
IF_MINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IF_MINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_MINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IF_MINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)

Additionally, the following usable rules for innermost can be oriented:

app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(false) = 0

POL(if_rm(x₁, x₂, x₃)) = x₃

POL(true) = 0

POL(rm(x₁, x₂)) = x₂

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

POL(if_min(x₁, x₂)) = x₂

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

POL(IF_MINSORT(x₁, x₂, x₃)) = x₂ + x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 1

POL(nil) = 0

POL(min(x₁)) = x₁

POL(s(x₁)) = 0

POL(le(x₁, x₂)) = 0

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 75

                 ↳Polynomial Ordering

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
IF_MINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IF_MINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_MINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(add(0, app(rm(s(x'), x''), y)), nil)
IF_MINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(if_rm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)

Additionally, the following usable rules for innermost can be oriented:

app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(false) = 0

POL(if_rm(x₁, x₂, x₃)) = x₃

POL(true) = 0

POL(rm(x₁, x₂)) = x₂

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

POL(if_min(x₁, x₂)) = x₂

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

POL(IF_MINSORT(x₁, x₂, x₃)) = x₂ + x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 0

POL(nil) = 0

POL(min(x₁)) = x₁

POL(s(x₁)) = 1

POL(le(x₁, x₂)) = 0

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 76

                 ↳Polynomial Ordering

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
IF_MINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IF_MINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_MINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)

Additionally, the following usable rules for innermost can be oriented:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_MINSORT(x₁, x₂, x₃)) = x₂ + x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 0

POL(false) = 0

POL(true) = 0

POL(min(x₁)) = x₁

POL(nil) = 0

POL(s(x₁)) = 0

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

POL(le(x₁, x₂)) = 0

POL(if_min(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 77

                 ↳Dependency Graph

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
IF_MINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IF_MINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IF_MINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IF_MINSORT(eq(x', x'), add(s(x'), nil), y)
MINSORT(add(0, nil), y) -> IF_MINSORT(true, add(0, nil), y)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph the DP problem was split into 1 DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 78

                 ↳Polynomial Ordering

Dependency Pairs:

IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_MINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IF_MINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IF_MINSORT(false, add(0, add(s(x'''0), add(s(y''''), x''''''))), y''0) -> MINSORT(add(s(x'''0), add(s(y''''), x'''''')), add(0, y''0))

Additionally, the following usable rules for innermost can be oriented:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_MINSORT(x₁, x₂, x₃)) = x₂

POL(eq(x₁, x₂)) = 0

POL(0) = 1

POL(false) = 0

POL(true) = 0

POL(min(x₁)) = x₁

POL(nil) = 1

POL(s(x₁)) = 0

POL(MINSORT(x₁, x₂)) = x₁

POL(le(x₁, x₂)) = 0

POL(if_min(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 79

                 ↳Dependency Graph

Dependency Pairs:

IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IF_MINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
MINSORT(add(s(x'), add(0, x'')), y) -> IF_MINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph the DP problem was split into 1 DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 80

                 ↳Polynomial Ordering

Dependency Pairs:

MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_MINSORT(false, add(s(x'''0'), add(s(y''''''), add(s(y'''''), x''''''))), y''0) -> MINSORT(add(s(y''''''), add(s(y'''''), x'''''')), add(s(x'''0'), y''0))

Additionally, the following usable rules for innermost can be oriented:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(IF_MINSORT(x₁, x₂, x₃)) = x₂

POL(eq(x₁, x₂)) = 0

POL(0) = 0

POL(false) = 0

POL(true) = 0

POL(min(x₁)) = x₁

POL(nil) = 1

POL(s(x₁)) = 1

POL(MINSORT(x₁, x₂)) = x₁

POL(le(x₁, x₂)) = 0

POL(if_min(x₁, x₂)) = x₂

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

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

       →DP Problem 5

         ↳Nar

       →DP Problem 6

         ↳Nar

           →DP Problem 58

             ↳Nar

...

               →DP Problem 81

                 ↳Dependency Graph

Dependency Pair:

MINSORT(add(s(x'), add(s(y''), x'')), y) -> IF_MINSORT(eq(s(x'), if_min(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)

Rules:

eq(0, 0) -> true
eq(0, s(x)) -> false
eq(s(x), 0) -> false
eq(s(x), s(y)) -> eq(x, y)
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))
min(add(n, nil)) -> n
min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) -> min(add(n, x))
if_min(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) -> rm(n, x)
if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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

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

POL(IF_RM(x₁, x₂, x₃))	= x₃
POL(eq(x₁, x₂))	= 0
POL(0)	= 1
POL(false)	= 0
POL(true)	= 0
POL(s(x₁))	= 0
POL(RM(x₁, x₂))	= x₂
POL(add(x₁, x₂))	= x₁ + x₂

POL(0)	= 0
POL(MIN(x₁))	= x₁
POL(true)	= 0
POL(IF_MIN(x₁, x₂))	= x₂
POL(add(x₁, x₂))	= 1 + x₂

POL(IF_MINSORT(x₁, x₂, x₃))	= x₂ + x₃
POL(eq(x₁, x₂))	= 0
POL(0)	= 0
POL(false)	= 0
POL(true)	= 0
POL(min(x₁))	= x₁
POL(nil)	= 0
POL(s(x₁))	= 0
POL(MINSORT(x₁, x₂))	= x₁ + x₂
POL(le(x₁, x₂))	= 0
POL(if_min(x₁, x₂))	= x₂
POL(add(x₁, x₂))	= 1 + x₁ + x₂