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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))

Innermost Termination of R to be shown. 



   R
     ↳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))) -> IFMIN(le(n, m), add(n, add(m, x)))
MIN(add(n, add(m, x))) -> LE(n, m)
IFMIN(true, add(n, add(m, x))) -> MIN(add(n, x))
IFMIN(false, add(n, add(m, x))) -> MIN(add(m, x))
RM(n, add(m, x)) -> IFRM(eq(n, m), n, add(m, x))
RM(n, add(m, x)) -> EQ(n, m)
IFRM(true, n, add(m, x)) -> RM(n, x)
IFRM(false, n, add(m, x)) -> RM(n, x)
MINSORT(add(n, x), y) -> IFMINSORT(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))
IFMINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
IFMINSORT(true, add(n, x), y) -> APP(rm(n, x), y)
IFMINSORT(true, add(n, x), y) -> RM(n, x)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))

Furthermore, R contains six SCCs. 


   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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: 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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: 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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 w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(EQ(x1, x2))=  1 + x1  
  POL(s(x1))=  1 + x1  

resulting in one new DP problem. 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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: 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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: 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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 w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(LE(x1, x2))=  1 + x1  
  POL(s(x1))=  1 + x1  

resulting in one new DP problem. 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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: 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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: 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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 w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(APP(x1, x2))=  1 + x1  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳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:

IFRM(false, n, add(m, x)) -> RM(n, x)
IFRM(true, n, add(m, x)) -> RM(n, x)
RM(n, add(m, x)) -> IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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)) -> IFRM(eq(n, m), n, add(m, x))
four new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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)) -> IFRM(eq(x'', y'), s(x''), add(s(y'), x))
RM(s(x''), add(0, x)) -> IFRM(false, s(x''), add(0, x))
RM(0, add(s(x''), x)) -> IFRM(false, 0, add(s(x''), x))
IFRM(true, n, add(m, x)) -> RM(n, x)
RM(0, add(0, x)) -> IFRM(true, 0, add(0, x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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)) -> IFRM(eq(x'', y'), s(x''), add(s(y'), x))
four new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
RM(0, add(s(x''), x)) -> IFRM(false, 0, add(s(x''), x))
IFRM(true, n, add(m, x)) -> RM(n, x)
RM(0, add(0, x)) -> IFRM(true, 0, add(0, x))
IFRM(false, n, add(m, x)) -> RM(n, x)
RM(s(x''), add(0, x)) -> IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(true, n, add(m, x)) -> RM(n, x)
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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:

IFRM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
RM(s(x''), add(0, x)) -> IFRM(false, s(x''), add(0, x))
RM(0, add(s(x''), x)) -> IFRM(false, 0, add(s(x''), x))
IFRM(true, 0, add(0, x'')) -> RM(0, x'')
RM(0, add(0, x)) -> IFRM(true, 0, add(0, x))
IFRM(false, n, add(m, x)) -> RM(n, x)
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(false, n, add(m, x)) -> RM(n, x)
five new Dependency Pairs are created:

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

The transformation is resulting in two new DP problems: 



   R
     ↳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:

IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
RM(s(x''), add(0, x)) -> IFRM(false, s(x''), add(0, x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(true, s(0), add(s(0), x'')) -> RM(s(0), x'')
three new Dependency Pairs are created:

IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(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: 



   R
     ↳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:

IFRM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
RM(s(x''), add(0, x)) -> IFRM(false, s(x''), add(0, x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(true, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
three new Dependency Pairs are created:

IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(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: 



   R
     ↳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:

IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
RM(s(x''), add(0, x)) -> IFRM(false, s(x''), add(0, x))
IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(false, s(x''''), add(0, x'')) -> RM(s(x''''), x'')
five new Dependency Pairs are created:

IFRM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
IFRM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
IFRM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(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: 



   R
     ↳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:

IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(false, s(s(x'''''')), add(0, add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(false, s(s(x'''''')), add(0, add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(false, s(0), add(0, add(s(s(x'''''')), x'''))) -> RM(s(0), add(s(s(x'''''')), x'''))
IFRM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(false, s(0), add(0, add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, x'0))
RM(s(x''), add(0, x)) -> IFRM(false, s(x''), add(0, x))
IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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)) -> IFRM(false, s(x''), add(0, x))
five new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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:

IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(0), x''''')))
IFRM(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''))) -> IFRM(false, s(x'''), add(0, add(0, x'0'')))
IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(false, s(0), add(s(s(x''''')), x'')) -> RM(s(0), x'')
five new Dependency Pairs are created:

IFRM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IFRM(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: 



   R
     ↳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:

IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IFRM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(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)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(0), x''''')))
IFRM(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''))) -> IFRM(false, s(x'''), add(0, add(0, x'0'')))
IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(false, s(s(x''''')), add(s(0), x'')) -> RM(s(s(x''''')), x'')
five new Dependency Pairs are created:

IFRM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(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''''''')))
IFRM(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: 



   R
     ↳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:

IFRM(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''''''')))
IFRM(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''''''')))
IFRM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IFRM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(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)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(0), x''''')))
IFRM(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''))) -> IFRM(false, s(x'''), add(0, add(0, x'0'')))
IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(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)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(false, s(s(x''''')), add(s(s(y'''')), x')) -> RM(s(s(x''''')), x')
five new Dependency Pairs are created:

IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(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''''''')))
IFRM(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: 



   R
     ↳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:

IFRM(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''''''')))
IFRM(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''''''')))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(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''''''')))
IFRM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(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)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IFRM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(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)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(0), x''''')))
IFRM(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''))) -> IFRM(false, s(x'''), add(0, add(0, x'0'')))
IFRM(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)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(s(y'''''')), x''''')))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

IFRM(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''''''')))
IFRM(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''''''')))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(false, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(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''''''')))
IFRM(false, s(s(x'''''')), add(s(0), add(0, add(0, x'0'''')))) -> RM(s(s(x'''''')), add(0, add(0, x'0'''')))
IFRM(false, s(s(x'''''')), add(s(0), add(s(s(y'''')), x'''))) -> RM(s(s(x'''''')), add(s(s(y'''')), x'''))
IFRM(false, s(s(x'''''')), add(s(0), add(s(0), x'''))) -> RM(s(s(x'''''')), add(s(0), x'''))
IFRM(true, s(0), add(s(0), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(true, s(0), add(s(0), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(s(x'''''''''')), x''''''')))) -> RM(s(0), add(0, add(s(s(x'''''''''')), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(s(0), x''''''')))) -> RM(s(0), add(0, add(s(0), x''''''')))
IFRM(false, s(0), add(s(s(x''''')), add(0, add(0, x'0'''')))) -> RM(s(0), add(0, add(0, x'0'''')))
IFRM(false, s(0), add(s(s(x''''')), add(s(s(x''''')), x'''))) -> RM(s(0), add(s(s(x''''')), x'''))
IFRM(false, s(0), add(s(s(x''''')), add(s(0), x'''))) -> RM(s(0), add(s(0), x'''))
IFRM(true, s(0), add(s(0), add(0, x'0))) -> RM(s(0), add(0, x'0))
IFRM(true, s(s(x'''''')), add(s(s(y'''')), add(0, x0'))) -> RM(s(s(x'''''')), add(0, x0'))
IFRM(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''''''')))


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_RM(x1, x2, x3))=  x3  
  POL(eq(x1, x2))=  0  
  POL(0)=  0  
  POL(false)=  0  
  POL(true)=  0  
  POL(s(x1))=  1  
  POL(RM(x1, x2))=  x2  
  POL(add(x1, x2))=  x1 + x2  

resulting in one new DP problem. 



   R
     ↳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:

RM(s(s(x''')), add(s(0), x)) -> IFRM(false, s(s(x''')), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), add(0, add(s(0), x''''')))
RM(s(0), add(s(s(x''')), x)) -> IFRM(false, s(0), add(s(s(x''')), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(s(x'''''''')), x''''')))
RM(s(0), add(s(0), x)) -> IFRM(true, s(0), add(s(0), x))
IFRM(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'''''))) -> IFRM(false, s(0), add(0, add(s(0), x''''')))
IFRM(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''))) -> IFRM(false, s(x'''), add(0, add(0, x'0'')))
RM(s(s(x''')), add(s(s(y'')), x)) -> IFRM(eq(x''', y''), s(s(x''')), add(s(s(y'')), x))
IFRM(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'''''))) -> IFRM(false, s(s(x'''''''')), 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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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.


   R
     ↳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:

RM(s(x'''), add(0, add(0, x'0''))) -> IFRM(false, s(x'''), add(0, add(0, x'0'')))
IFRM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, 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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_RM(x1, x2, x3))=  x3  
  POL(0)=  0  
  POL(false)=  0  
  POL(s(x1))=  0  
  POL(RM(x1, x2))=  1 + x2  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳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:

IFRM(false, s(x'''''), add(0, add(0, x'0))) -> RM(s(x'''''), add(0, 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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳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:

IFRM(true, 0, add(0, x'')) -> RM(0, x'')
RM(0, add(0, x)) -> IFRM(true, 0, add(0, x))
IFRM(false, 0, add(s(x''''), x'')) -> RM(0, x'')
RM(0, add(s(x''), x)) -> IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(true, 0, add(0, x'')) -> RM(0, x'')
two new Dependency Pairs are created:

IFRM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
IFRM(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: 



   R
     ↳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:

IFRM(false, 0, add(s(x''''), x'')) -> RM(0, x'')
RM(0, add(s(x''), x)) -> IFRM(false, 0, add(s(x''), x))
IFRM(true, 0, add(0, add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
IFRM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, x)) -> IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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)) -> IFRM(true, 0, add(0, x))
two new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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:

IFRM(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''))) -> IFRM(true, 0, add(0, add(s(x''''''), x'0'')))
IFRM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IFRM(true, 0, add(0, add(0, x''''')))
RM(0, add(s(x''), x)) -> IFRM(false, 0, add(s(x''), x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFRM(false, 0, add(s(x''''), x'')) -> RM(0, x'')
three new Dependency Pairs are created:

IFRM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
IFRM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
IFRM(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: 



   R
     ↳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:

IFRM(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''))) -> IFRM(true, 0, add(0, add(s(x''''''), x'0'')))
IFRM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IFRM(true, 0, add(0, add(0, x''''')))
IFRM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
IFRM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
RM(0, add(s(x''), x)) -> IFRM(false, 0, add(s(x''), x))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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)) -> IFRM(false, 0, add(s(x''), x))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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'''''')))) -> IFRM(false, 0, add(s(x'''), add(0, add(s(x''''''''''), x'0''''''))))
IFRM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IFRM(true, 0, add(0, add(0, x''''')))
IFRM(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''''''''')))) -> IFRM(false, 0, add(s(x'''), add(0, add(0, x'''''''''))))
IFRM(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''))) -> IFRM(false, 0, add(s(x'''), add(s(x'''''''), x'0'')))
IFRM(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''))) -> IFRM(true, 0, add(0, add(s(x''''''), x'0'')))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

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


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_RM(x1, x2, x3))=  x1 + x3  
  POL(0)=  0  
  POL(false)=  0  
  POL(true)=  1  
  POL(s(x1))=  1  
  POL(RM(x1, x2))=  1 + x2  
  POL(add(x1, x2))=  x1 + x2  

resulting in one new DP problem. 



   R
     ↳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:

IFRM(true, 0, add(0, add(0, x'''))) -> RM(0, add(0, x'''))
RM(0, add(0, add(0, x'''''))) -> IFRM(true, 0, add(0, add(0, x''''')))
IFRM(false, 0, add(s(x''''), add(0, add(0, x''''''')))) -> RM(0, add(0, add(0, x''''''')))
IFRM(false, 0, add(s(x''''), add(s(x''''), x'0))) -> RM(0, add(s(x''''), x'0))
IFRM(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''))) -> IFRM(true, 0, add(0, add(s(x''''''), x'0'')))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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.


   R
     ↳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'''''))) -> IFRM(true, 0, add(0, add(0, x''''')))
IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_RM(x1, x2, x3))=  x3  
  POL(0)=  0  
  POL(true)=  0  
  POL(RM(x1, x2))=  1 + x2  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
           →DP Problem 16
             ↳Nar
             ...
               →DP Problem 36
                 ↳Dependency Graph
       →DP Problem 5
         ↳Nar
       →DP Problem 6
         ↳Nar


Dependency Pair:

IFRM(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳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:

IFMIN(false, add(n, add(m, x))) -> MIN(add(m, x))
IFMIN(true, add(n, add(m, x))) -> MIN(add(n, x))
MIN(add(n, add(m, x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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))) -> IFMIN(le(n, m), add(n, add(m, x)))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Narrowing Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

MIN(add(s(x''), add(s(y'), x))) -> IFMIN(le(x'', y'), add(s(x''), add(s(y'), x)))
MIN(add(s(x''), add(0, x))) -> IFMIN(false, add(s(x''), add(0, x)))
IFMIN(true, add(n, add(m, x))) -> MIN(add(n, x))
MIN(add(0, add(m', x))) -> IFMIN(true, add(0, add(m', x)))
IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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))) -> IFMIN(le(x'', y'), add(s(x''), add(s(y'), x)))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 39
                 ↳Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IFMIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
MIN(add(s(s(x''')), add(s(0), x))) -> IFMIN(false, add(s(s(x''')), add(s(0), x)))
MIN(add(s(0), add(s(y''), x))) -> IFMIN(true, add(s(0), add(s(y''), x)))
IFMIN(true, add(n, add(m, x))) -> MIN(add(n, x))
MIN(add(0, add(m', x))) -> IFMIN(true, add(0, add(m', x)))
IFMIN(false, add(n, add(m, x))) -> MIN(add(m, x))
MIN(add(s(x''), add(0, x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMIN(true, add(n, add(m, x))) -> MIN(add(n, x))
three new Dependency Pairs are created:

IFMIN(true, add(0, add(m', x''))) -> MIN(add(0, x''))
IFMIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
IFMIN(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: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 40
                 ↳Forward Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(true, add(0, add(m', x''))) -> MIN(add(0, x''))
MIN(add(0, add(m', x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMIN(true, add(0, add(m', x''))) -> MIN(add(0, x''))
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 42
                 ↳Forward Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(true, add(0, add(m', add(m''', x''')))) -> MIN(add(0, add(m''', x''')))
MIN(add(0, add(m', x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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))) -> IFMIN(true, add(0, add(m', x)))
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 45
                 ↳Polynomial Ordering
       →DP Problem 6
         ↳Nar


Dependency Pairs:

MIN(add(0, add(m''', add(m''''', x''''')))) -> IFMIN(true, add(0, add(m''', add(m''''', x'''''))))
IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(0)=  0  
  POL(MIN(x1))=  1 + x1  
  POL(true)=  0  
  POL(IF_MIN(x1, x2))=  x2  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 49
                 ↳Dependency Graph
       →DP Problem 6
         ↳Nar


Dependency Pair:

IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 41
                 ↳Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(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))) -> IFMIN(false, add(s(s(x''')), add(s(0), x)))
IFMIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
MIN(add(s(0), add(s(y''), x))) -> IFMIN(true, add(s(0), add(s(y''), x)))
MIN(add(s(x''), add(0, x))) -> IFMIN(false, add(s(x''), add(0, x)))
IFMIN(false, add(n, add(m, x))) -> MIN(add(m, x))
MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMIN(false, add(n, add(m, x))) -> MIN(add(m, x))
three new Dependency Pairs are created:

IFMIN(false, add(s(x''''), add(0, x''))) -> MIN(add(0, x''))
IFMIN(false, add(s(s(x''''')), add(s(0), x''))) -> MIN(add(s(0), x''))
IFMIN(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: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 43
                 ↳Forward Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
MIN(add(s(0), add(s(y''), x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMIN(true, add(s(0), add(s(y''''), x''))) -> MIN(add(s(0), x''))
one new Dependency Pair is created:

IFMIN(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: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 46
                 ↳Polynomial Ordering
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(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))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pair can be strictly oriented:

IFMIN(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 w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(0)=  0  
  POL(MIN(x1))=  x1  
  POL(true)=  0  
  POL(IF_MIN(x1, x2))=  x2  
  POL(s(x1))=  1  
  POL(add(x1, x2))=  x1 + x2  

resulting in one new DP problem. 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 50
                 ↳Dependency Graph
       →DP Problem 6
         ↳Nar


Dependency Pair:

MIN(add(s(0), add(s(y''), x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 44
                 ↳Forward Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(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))) -> IFMIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMIN(true, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(x''''')), x'))
one new Dependency Pair is created:

IFMIN(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: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 47
                 ↳Forward Instantiation Transformation
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(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))) -> IFMIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMIN(false, add(s(s(x''''')), add(s(s(y'''')), x'))) -> MIN(add(s(s(y'''')), x'))
one new Dependency Pair is created:

IFMIN(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: 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 48
                 ↳Polynomial Ordering
       →DP Problem 6
         ↳Nar


Dependency Pairs:

IFMIN(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))) -> IFMIN(le(x''', y''), add(s(s(x''')), add(s(s(y'')), x)))
IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

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


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(0)=  0  
  POL(false)=  0  
  POL(MIN(x1))=  x1  
  POL(true)=  0  
  POL(s(x1))=  0  
  POL(IF_MIN(x1, x2))=  x2  
  POL(le(x1, x2))=  0  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳DPs
       →DP Problem 1
         ↳FwdInst
       →DP Problem 2
         ↳FwdInst
       →DP Problem 3
         ↳FwdInst
       →DP Problem 4
         ↳Nar
       →DP Problem 5
         ↳Nar
           →DP Problem 38
             ↳Nar
             ...
               →DP Problem 51
                 ↳Dependency Graph
       →DP Problem 6
         ↳Nar


Dependency Pair:

MIN(add(s(s(x''')), add(s(s(y'')), x))) -> IFMIN(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
     ↳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:

IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
IFMINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
MINSORT(add(n, x), y) -> IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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) -> IFMINSORT(eq(n, min(add(n, x))), add(n, x), y)
two new Dependency Pairs are created:

MINSORT(add(n'', nil), y) -> IFMINSORT(eq(n'', n''), add(n'', nil), y)
MINSORT(add(n'', add(m', x'')), y) -> IFMINSORT(eq(n'', ifmin(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Narrowing Transformation


Dependency Pairs:

MINSORT(add(n'', add(m', x'')), y) -> IFMINSORT(eq(n'', ifmin(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)
IFMINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
MINSORT(add(n'', nil), y) -> IFMINSORT(eq(n'', n''), add(n'', nil), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(n, x), y) -> MINSORT(app(rm(n, x), y), nil)
two new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 53
                 ↳Rewriting Transformation


Dependency Pairs:

IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(eq(n'', m'), n'', add(m', x'')), y), nil)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(app(nil, y), nil)
MINSORT(add(n'', nil), y) -> IFMINSORT(eq(n'', n''), add(n'', nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(n'', add(m', x'')), y) -> IFMINSORT(eq(n'', ifmin(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(n'', nil), y) -> MINSORT(app(nil, y), nil)
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 54
                 ↳Narrowing Transformation


Dependency Pairs:

IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(n'', add(m', x'')), y) -> IFMINSORT(eq(n'', ifmin(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(n'', nil), y) -> IFMINSORT(eq(n'', n''), add(n'', nil), y)
IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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) -> IFMINSORT(eq(n'', n''), add(n'', nil), y)
two new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 55
                 ↳Narrowing Transformation


Dependency Pairs:

IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(eq(n'', m'), n'', add(m', x'')), y), nil)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(n'', add(m', x'')), y) -> IFMINSORT(eq(n'', ifmin(le(n'', m'), add(n'', add(m', x'')))), add(n'', add(m', x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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) -> IFMINSORT(eq(n'', ifmin(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) -> IFMINSORT(eq(0, ifmin(true, add(0, add(m'', x'')))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(eq(s(x'), ifmin(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 56
                 ↳Rewriting Transformation


Dependency Pairs:

MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(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) -> IFMINSORT(eq(s(x'), ifmin(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, ifmin(true, add(0, add(m'', x'')))), add(0, add(m'', x'')), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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) -> IFMINSORT(eq(0, ifmin(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) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 57
                 ↳Rewriting Transformation


Dependency Pairs:

MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(eq(n'', m'), n'', add(m', x'')), y), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(eq(s(x'), ifmin(false, add(s(x'), add(0, x'')))), add(s(x'), add(0, x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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) -> IFMINSORT(eq(s(x'), ifmin(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 58
                 ↳Narrowing Transformation


Dependency Pairs:

MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(eq(n'', m'), n'', add(m', x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(n'', add(m', x'')), y) -> MINSORT(app(ifrm(eq(n'', m'), n'', add(m', x'')), y), nil)
four new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 59
                 ↳Rewriting Transformation


Dependency Pairs:

IFMINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(ifrm(false, s(x'), add(0, x'')), y), nil)
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(ifrm(false, 0, add(s(x'), x'')), y), nil)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(ifrm(true, 0, add(0, x'')), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(ifrm(true, 0, add(0, x'')), y), nil)
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 60
                 ↳Rewriting Transformation


Dependency Pairs:

IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(ifrm(false, 0, add(s(x'), x'')), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(ifrm(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(ifrm(false, 0, add(s(x'), x'')), y), nil)
one new Dependency Pair is created:

IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 61
                 ↳Rewriting Transformation


Dependency Pairs:

IFMINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(ifrm(false, s(x'), add(0, x'')), y), nil)
MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(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) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(ifrm(false, s(x'), add(0, x'')), y), nil)
one new Dependency Pair is created:

IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 62
                 ↳Rewriting Transformation


Dependency Pairs:

IFMINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(add(0, rm(s(x'), x'')), y), nil)
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(add(s(x'), rm(0, x'')), y), nil)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), add(0, x'')), y) -> IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(app(add(s(x'), rm(0, x'')), y), nil)
one new Dependency Pair is created:

IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 63
                 ↳Rewriting Transformation


Dependency Pairs:

IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(true, add(s(x'), add(0, x'')), y) -> MINSORT(app(add(0, rm(s(x'), x'')), y), nil)
one new Dependency Pair is created:

IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 64
                 ↳Instantiation Transformation


Dependency Pairs:

IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(false, add(n, x), y) -> MINSORT(x, add(n, y))
four new Dependency Pairs are created:

IFMINSORT(false, add(s(x'0'), nil), y'') -> MINSORT(nil, add(s(x'0'), y''))
IFMINSORT(false, add(s(x'''0), add(s(y''''), x''''')), y'') -> MINSORT(add(s(y''''), x'''''), add(s(x'''0), y''))
IFMINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))
IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 65
                 ↳Forward Instantiation Transformation


Dependency Pairs:

IFMINSORT(false, add(s(x'''0), add(s(y''''), x''''')), y'') -> MINSORT(add(s(y''''), x'''''), add(s(x'''0), y''))
IFMINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(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:

IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(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))
IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 66
                 ↳Forward Instantiation Transformation


Dependency Pairs:

IFMINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IFMINSORT(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))
IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IFMINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(false, add(0, add(m'''', x''''')), y'') -> MINSORT(add(m'''', x'''''), add(0, y''))
five new Dependency Pairs are created:

IFMINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IFMINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IFMINSORT(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))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 67
                 ↳Forward Instantiation Transformation


Dependency Pairs:

IFMINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))
IFMINSORT(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))
IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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))
IFMINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IFMINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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

IFMINSORT(false, add(s(x'''0), add(0, x''''')), y'') -> MINSORT(add(0, x'''''), add(s(x'''0), y''))
two new Dependency Pairs are created:

IFMINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
IFMINSORT(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: 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 68
                 ↳Polynomial Ordering


Dependency Pairs:

IFMINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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))
IFMINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IFMINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IFMINSORT(true, add(0, add(s(x'), x'')), y) -> MINSORT(add(s(x'), app(rm(0, x''), y)), nil)
IFMINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IFMINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(true, add(0, add(0, x'')), y) -> MINSORT(app(rm(0, x''), y), nil)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

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


Additionally, the following usable rules for innermost w.r.t. to the implicit AFS can be oriented:

ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(false)=  0  
  POL(if_rm(x1, x2, x3))=  x3  
  POL(true)=  0  
  POL(rm(x1, x2))=  x2  
  POL(MINSORT(x1, x2))=  x1 + x2  
  POL(if_min(x1, x2))=  0  
  POL(add(x1, x2))=  x1 + x2  
  POL(IF_MINSORT(x1, x2, x3))=  x2 + x3  
  POL(eq(x1, x2))=  0  
  POL(0)=  1  
  POL(nil)=  0  
  POL(min(x1))=  0  
  POL(s(x1))=  0  
  POL(le(x1, x2))=  0  
  POL(app(x1, x2))=  x1 + x2  

resulting in one new DP problem. 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 69
                 ↳Polynomial Ordering


Dependency Pairs:

IFMINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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))
IFMINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IFMINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IFMINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IFMINSORT(false, add(s(x'''0'), add(0, nil)), y''') -> MINSORT(add(0, nil), add(s(x'''0'), y'''))
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
IFMINSORT(true, add(s(x'), add(s(y''), x'')), y) -> MINSORT(app(ifrm(eq(x', y''), s(x'), add(s(y''), x'')), y), nil)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

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


Additionally, the following usable rules for innermost w.r.t. to the implicit AFS can be oriented:

ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
app(nil, y) -> y
app(add(n, x), y) -> add(n, app(x, y))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(false)=  0  
  POL(if_rm(x1, x2, x3))=  x3  
  POL(true)=  0  
  POL(rm(x1, x2))=  x2  
  POL(MINSORT(x1, x2))=  x1 + x2  
  POL(if_min(x1, x2))=  0  
  POL(add(x1, x2))=  x1 + x2  
  POL(IF_MINSORT(x1, x2, x3))=  x2 + x3  
  POL(eq(x1, x2))=  0  
  POL(0)=  0  
  POL(nil)=  0  
  POL(min(x1))=  0  
  POL(s(x1))=  1  
  POL(le(x1, x2))=  0  
  POL(app(x1, x2))=  x1 + x2  

resulting in one new DP problem. 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 70
                 ↳Polynomial Ordering


Dependency Pairs:

IFMINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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))
IFMINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IFMINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IFMINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
IFMINSORT(true, add(n'', nil), y) -> MINSORT(y, nil)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_MINSORT(x1, x2, x3))=  x2 + x3  
  POL(eq(x1, x2))=  0  
  POL(0)=  0  
  POL(false)=  0  
  POL(true)=  0  
  POL(min(x1))=  0  
  POL(nil)=  0  
  POL(s(x1))=  0  
  POL(MINSORT(x1, x2))=  x1 + x2  
  POL(le(x1, x2))=  0  
  POL(if_min(x1, x2))=  0  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 71
                 ↳Dependency Graph


Dependency Pairs:

IFMINSORT(false, add(s(x'''0'), add(s(y'''''), add(0, x''''''))), y''') -> MINSORT(add(s(y'''''), add(0, x'''''')), add(s(x'''0'), y'''))
IFMINSORT(false, add(s(x'''0'), add(s(y'''''), nil)), y''') -> MINSORT(add(s(y'''''), nil), add(s(x'''0'), y'''))
IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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))
IFMINSORT(false, add(0, add(s(x'''), nil)), y''') -> MINSORT(add(s(x'''), nil), add(0, y'''))
IFMINSORT(false, add(0, add(0, nil)), y''') -> MINSORT(add(0, nil), add(0, y'''))
IFMINSORT(false, add(s(x'''0'), add(0, add(m'''', x''''))), y''') -> MINSORT(add(0, add(m'''', x'''')), add(s(x'''0'), y'''))
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
MINSORT(add(0, add(m'', x'')), y) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
MINSORT(add(s(x'), nil), y) -> IFMINSORT(eq(x', x'), add(s(x'), nil), y)
MINSORT(add(0, nil), y) -> IFMINSORT(true, add(0, nil), y)
MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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.


   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 72
                 ↳Polynomial Ordering


Dependency Pairs:

IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(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) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

IFMINSORT(false, add(0, add(s(x'''0), add(0, x''''''))), y''') -> MINSORT(add(s(x'''0), add(0, x'''''')), add(0, y'''))
IFMINSORT(false, add(0, add(0, add(m''''', x''''))), y''') -> MINSORT(add(0, add(m''''', x'''')), add(0, y'''))
IFMINSORT(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))


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_MINSORT(x1, x2, x3))=  x2  
  POL(eq(x1, x2))=  0  
  POL(0)=  1  
  POL(false)=  0  
  POL(true)=  0  
  POL(min(x1))=  0  
  POL(nil)=  0  
  POL(s(x1))=  0  
  POL(MINSORT(x1, x2))=  x1  
  POL(le(x1, x2))=  0  
  POL(if_min(x1, x2))=  0  
  POL(add(x1, x2))=  x1 + x2  

resulting in one new DP problem. 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 73
                 ↳Dependency Graph


Dependency Pairs:

IFMINSORT(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) -> IFMINSORT(eq(s(x'), ifmin(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) -> IFMINSORT(eq(0, min(add(0, x''))), add(0, add(m'', x'')), y)
IFMINSORT(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) -> IFMINSORT(eq(s(x'), min(add(0, x''))), add(s(x'), add(0, x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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.


   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 74
                 ↳Polynomial Ordering


Dependency Pairs:

MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)
IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(false, add(n, x), y) -> minsort(x, add(n, y))


Strategy:

innermost




The following dependency pair can be strictly oriented:

MINSORT(add(s(x'), add(s(y''), x'')), y) -> IFMINSORT(eq(s(x'), ifmin(le(x', y''), add(s(x'), add(s(y''), x'')))), add(s(x'), add(s(y''), x'')), y)


There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_MINSORT(x1, x2, x3))=  x2  
  POL(eq(x1, x2))=  0  
  POL(0)=  0  
  POL(false)=  0  
  POL(true)=  0  
  POL(min(x1))=  0  
  POL(nil)=  0  
  POL(s(x1))=  0  
  POL(MINSORT(x1, x2))=  1 + x1  
  POL(le(x1, x2))=  0  
  POL(if_min(x1, x2))=  0  
  POL(add(x1, x2))=  1 + x2  

resulting in one new DP problem. 



   R
     ↳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 52
             ↳Nar
             ...
               →DP Problem 75
                 ↳Dependency Graph


Dependency Pair:

IFMINSORT(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))) -> ifmin(le(n, m), add(n, add(m, x)))
ifmin(true, add(n, add(m, x))) -> min(add(n, x))
ifmin(false, add(n, add(m, x))) -> min(add(m, x))
rm(n, nil) -> nil
rm(n, add(m, x)) -> ifrm(eq(n, m), n, add(m, x))
ifrm(true, n, add(m, x)) -> rm(n, x)
ifrm(false, n, add(m, x)) -> add(m, rm(n, x))
minsort(nil, nil) -> nil
minsort(add(n, x), y) -> ifminsort(eq(n, min(add(n, x))), add(n, x), y)
ifminsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
ifminsort(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:37 minutes