Term Rewriting System R:
[y, x]
le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)

Innermost Termination of R to be shown.



   R
Dependency Pair Analysis



R contains the following Dependency Pairs:

LE(s(x), s(y)) -> LE(x, y)
MINUS(s(x), y) -> IFMINUS(le(s(x), y), s(x), y)
MINUS(s(x), y) -> LE(s(x), y)
IFMINUS(false, s(x), y) -> MINUS(x, y)
MOD(s(x), s(y)) -> IFMOD(le(y, x), s(x), s(y))
MOD(s(x), s(y)) -> LE(y, x)
IFMOD(true, s(x), s(y)) -> MOD(minus(x, y), s(y))
IFMOD(true, s(x), s(y)) -> MINUS(x, y)

Furthermore, R contains three SCCs.


   R
DPs
       →DP Problem 1
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
Nar


Dependency Pair:

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


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


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 4
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
Nar


Dependency Pair:

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


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


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 4
FwdInst
             ...
               →DP Problem 5
Argument Filtering and Ordering
       →DP Problem 2
Nar
       →DP Problem 3
Nar


Dependency Pair:

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


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


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 AFS that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(LE(x1, x2))=  1 + x1 + x2  
  POL(s(x1))=  1 + x1  

resulting in one new DP problem.
Used Argument Filtering System:
LE(x1, x2) -> LE(x1, x2)
s(x1) -> s(x1)


   R
DPs
       →DP Problem 1
FwdInst
           →DP Problem 4
FwdInst
             ...
               →DP Problem 6
Dependency Graph
       →DP Problem 2
Nar
       →DP Problem 3
Nar


Dependency Pair:


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Narrowing Transformation
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(x), y) -> MINUS(x, y)
MINUS(s(x), y) -> IFMINUS(le(s(x), y), s(x), y)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

MINUS(s(x), y) -> IFMINUS(le(s(x), y), s(x), y)
two new Dependency Pairs are created:

MINUS(s(x''), 0) -> IFMINUS(false, s(x''), 0)
MINUS(s(x''), s(y'')) -> IFMINUS(le(x'', y''), s(x''), s(y''))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Narrowing Transformation
       →DP Problem 3
Nar


Dependency Pairs:

MINUS(s(x''), s(y'')) -> IFMINUS(le(x'', y''), s(x''), s(y''))
MINUS(s(x''), 0) -> IFMINUS(false, s(x''), 0)
IFMINUS(false, s(x), y) -> MINUS(x, y)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

MINUS(s(x''), s(y'')) -> IFMINUS(le(x'', y''), s(x''), s(y''))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 8
Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

MINUS(s(s(x')), s(s(y'))) -> IFMINUS(le(x', y'), s(s(x')), s(s(y')))
MINUS(s(s(x')), s(0)) -> IFMINUS(false, s(s(x')), s(0))
IFMINUS(false, s(x), y) -> MINUS(x, y)
MINUS(s(x''), 0) -> IFMINUS(false, s(x''), 0)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMINUS(false, s(x), y) -> MINUS(x, y)
three new Dependency Pairs are created:

IFMINUS(false, s(x'), 0) -> MINUS(x', 0)
IFMINUS(false, s(s(x''')), s(0)) -> MINUS(s(x'''), s(0))
IFMINUS(false, s(s(x'0')), s(s(y'''))) -> MINUS(s(x'0'), s(s(y''')))

The transformation is resulting in three new DP problems:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 9
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(s(x'0')), s(s(y'''))) -> MINUS(s(x'0'), s(s(y''')))
MINUS(s(s(x')), s(s(y'))) -> IFMINUS(le(x', y'), s(s(x')), s(s(y')))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMINUS(false, s(s(x'0')), s(s(y'''))) -> MINUS(s(x'0'), s(s(y''')))
one new Dependency Pair is created:

IFMINUS(false, s(s(s(x'''))), s(s(y''''))) -> MINUS(s(s(x''')), s(s(y'''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 12
Argument Filtering and Ordering
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(s(s(x'''))), s(s(y''''))) -> MINUS(s(s(x''')), s(s(y'''')))
MINUS(s(s(x')), s(s(y'))) -> IFMINUS(le(x', y'), s(s(x')), s(s(y')))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




The following dependency pair can be strictly oriented:

IFMINUS(false, s(s(s(x'''))), s(s(y''''))) -> MINUS(s(s(x''')), s(s(y'''')))


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

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


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_MINUS(x1, x2, x3))=  x1 + x2 + x3  
  POL(false)=  0  
  POL(MINUS(x1, x2))=  x1 + x2  
  POL(true)=  0  
  POL(s(x1))=  1 + x1  
  POL(le)=  0  

resulting in one new DP problem.
Used Argument Filtering System:
IFMINUS(x1, x2, x3) -> IFMINUS(x1, x2, x3)
MINUS(x1, x2) -> MINUS(x1, x2)
s(x1) -> s(x1)
le(x1, x2) -> le


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 16
Dependency Graph
       →DP Problem 3
Nar


Dependency Pair:

MINUS(s(s(x')), s(s(y'))) -> IFMINUS(le(x', y'), s(s(x')), s(s(y')))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 10
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(s(x''')), s(0)) -> MINUS(s(x'''), s(0))
MINUS(s(s(x')), s(0)) -> IFMINUS(false, s(s(x')), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMINUS(false, s(s(x''')), s(0)) -> MINUS(s(x'''), s(0))
one new Dependency Pair is created:

IFMINUS(false, s(s(s(x''''))), s(0)) -> MINUS(s(s(x'''')), s(0))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 13
Argument Filtering and Ordering
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(s(s(x''''))), s(0)) -> MINUS(s(s(x'''')), s(0))
MINUS(s(s(x')), s(0)) -> IFMINUS(false, s(s(x')), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




The following dependency pair can be strictly oriented:

IFMINUS(false, s(s(s(x''''))), s(0)) -> MINUS(s(s(x'''')), s(0))


There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_MINUS(x1, x2, x3))=  x1 + x2 + x3  
  POL(0)=  0  
  POL(false)=  0  
  POL(MINUS(x1, x2))=  x1 + x2  
  POL(s(x1))=  1 + x1  

resulting in one new DP problem.
Used Argument Filtering System:
IFMINUS(x1, x2, x3) -> IFMINUS(x1, x2, x3)
MINUS(x1, x2) -> MINUS(x1, x2)
s(x1) -> s(x1)


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 17
Dependency Graph
       →DP Problem 3
Nar


Dependency Pair:

MINUS(s(s(x')), s(0)) -> IFMINUS(false, s(s(x')), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 11
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(x'), 0) -> MINUS(x', 0)
MINUS(s(x''), 0) -> IFMINUS(false, s(x''), 0)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMINUS(false, s(x'), 0) -> MINUS(x', 0)
one new Dependency Pair is created:

IFMINUS(false, s(s(x'''')), 0) -> MINUS(s(x''''), 0)

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 14
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

IFMINUS(false, s(s(x'''')), 0) -> MINUS(s(x''''), 0)
MINUS(s(x''), 0) -> IFMINUS(false, s(x''), 0)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

MINUS(s(x''), 0) -> IFMINUS(false, s(x''), 0)
one new Dependency Pair is created:

MINUS(s(s(x'''''')), 0) -> IFMINUS(false, s(s(x'''''')), 0)

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 15
Argument Filtering and Ordering
       →DP Problem 3
Nar


Dependency Pairs:

MINUS(s(s(x'''''')), 0) -> IFMINUS(false, s(s(x'''''')), 0)
IFMINUS(false, s(s(x'''')), 0) -> MINUS(s(x''''), 0)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




The following dependency pair can be strictly oriented:

MINUS(s(s(x'''''')), 0) -> IFMINUS(false, s(s(x'''''')), 0)


There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(IF_MINUS(x1, x2, x3))=  x1 + x2 + x3  
  POL(0)=  0  
  POL(false)=  0  
  POL(MINUS(x1, x2))=  1 + x1 + x2  
  POL(s(x1))=  1 + x1  

resulting in one new DP problem.
Used Argument Filtering System:
MINUS(x1, x2) -> MINUS(x1, x2)
IFMINUS(x1, x2, x3) -> IFMINUS(x1, x2, x3)
s(x1) -> s(x1)


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 7
Nar
             ...
               →DP Problem 18
Dependency Graph
       →DP Problem 3
Nar


Dependency Pair:

IFMINUS(false, s(s(x'''')), 0) -> MINUS(s(x''''), 0)


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Narrowing Transformation


Dependency Pairs:

IFMOD(true, s(x), s(y)) -> MOD(minus(x, y), s(y))
MOD(s(x), s(y)) -> IFMOD(le(y, x), s(x), s(y))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

MOD(s(x), s(y)) -> IFMOD(le(y, x), s(x), s(y))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Narrowing Transformation


Dependency Pairs:

MOD(s(s(y'')), s(s(x''))) -> IFMOD(le(x'', y''), s(s(y'')), s(s(x'')))
MOD(s(x'), s(0)) -> IFMOD(true, s(x'), s(0))
IFMOD(true, s(x), s(y)) -> MOD(minus(x, y), s(y))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMOD(true, s(x), s(y)) -> MOD(minus(x, y), s(y))
two new Dependency Pairs are created:

IFMOD(true, s(0), s(y'')) -> MOD(0, s(y''))
IFMOD(true, s(s(x'')), s(y'')) -> MOD(ifminus(le(s(x''), y''), s(x''), y''), s(y''))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 20
Narrowing Transformation


Dependency Pairs:

MOD(s(x'), s(0)) -> IFMOD(true, s(x'), s(0))
IFMOD(true, s(s(x'')), s(y'')) -> MOD(ifminus(le(s(x''), y''), s(x''), y''), s(y''))
MOD(s(s(y'')), s(s(x''))) -> IFMOD(le(x'', y''), s(s(y'')), s(s(x'')))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

MOD(s(s(y'')), s(s(x''))) -> IFMOD(le(x'', y''), s(s(y'')), s(s(x'')))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 21
Narrowing Transformation


Dependency Pairs:

MOD(s(s(s(y'))), s(s(s(x')))) -> IFMOD(le(x', y'), s(s(s(y'))), s(s(s(x'))))
MOD(s(s(y''')), s(s(0))) -> IFMOD(true, s(s(y''')), s(s(0)))
IFMOD(true, s(s(x'')), s(y'')) -> MOD(ifminus(le(s(x''), y''), s(x''), y''), s(y''))
MOD(s(x'), s(0)) -> IFMOD(true, s(x'), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMOD(true, s(s(x'')), s(y'')) -> MOD(ifminus(le(s(x''), y''), s(x''), y''), s(y''))
two new Dependency Pairs are created:

IFMOD(true, s(s(x''')), s(0)) -> MOD(ifminus(false, s(x'''), 0), s(0))
IFMOD(true, s(s(x''')), s(s(y'))) -> MOD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))

The transformation is resulting in two new DP problems:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 22
Argument Filtering and Ordering


Dependency Pairs:

MOD(s(s(y''')), s(s(0))) -> IFMOD(true, s(s(y''')), s(s(0)))
IFMOD(true, s(s(x''')), s(s(y'))) -> MOD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))
MOD(s(s(s(y'))), s(s(s(x')))) -> IFMOD(le(x', y'), s(s(s(y'))), s(s(s(x'))))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




The following dependency pairs can be strictly oriented:

MOD(s(s(y''')), s(s(0))) -> IFMOD(true, s(s(y''')), s(s(0)))
MOD(s(s(s(y'))), s(s(s(x')))) -> IFMOD(le(x', y'), s(s(s(y'))), s(s(s(x'))))


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

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


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(0)=  0  
  POL(MOD(x1, x2))=  1 + x1 + x2  
  POL(false)=  0  
  POL(true)=  0  
  POL(s(x1))=  1 + x1  
  POL(IF_MOD(x1, x2, x3))=  x1 + x2 + x3  
  POL(le)=  0  

resulting in one new DP problem.
Used Argument Filtering System:
MOD(x1, x2) -> MOD(x1, x2)
IFMOD(x1, x2, x3) -> IFMOD(x1, x2, x3)
s(x1) -> s(x1)
le(x1, x2) -> le
ifminus(x1, x2, x3) -> x2
minus(x1, x2) -> x1


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 26
Dependency Graph


Dependency Pair:

IFMOD(true, s(s(x''')), s(s(y'))) -> MOD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 23
Rewriting Transformation


Dependency Pairs:

IFMOD(true, s(s(x''')), s(0)) -> MOD(ifminus(false, s(x'''), 0), s(0))
MOD(s(x'), s(0)) -> IFMOD(true, s(x'), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

IFMOD(true, s(s(x''')), s(0)) -> MOD(ifminus(false, s(x'''), 0), s(0))
one new Dependency Pair is created:

IFMOD(true, s(s(x''')), s(0)) -> MOD(s(minus(x''', 0)), s(0))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 24
Forward Instantiation Transformation


Dependency Pairs:

IFMOD(true, s(s(x''')), s(0)) -> MOD(s(minus(x''', 0)), s(0))
MOD(s(x'), s(0)) -> IFMOD(true, s(x'), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




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

MOD(s(x'), s(0)) -> IFMOD(true, s(x'), s(0))
one new Dependency Pair is created:

MOD(s(s(x''''')), s(0)) -> IFMOD(true, s(s(x''''')), s(0))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 25
Argument Filtering and Ordering


Dependency Pairs:

MOD(s(s(x''''')), s(0)) -> IFMOD(true, s(s(x''''')), s(0))
IFMOD(true, s(s(x''')), s(0)) -> MOD(s(minus(x''', 0)), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




The following dependency pair can be strictly oriented:

IFMOD(true, s(s(x''')), s(0)) -> MOD(s(minus(x''', 0)), s(0))


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

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


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(0)=  0  
  POL(MOD(x1, x2))=  x1 + x2  
  POL(false)=  0  
  POL(minus(x1, x2))=  x1 + x2  
  POL(true)=  0  
  POL(IF_MOD(x1, x2, x3))=  x1 + x2 + x3  
  POL(s(x1))=  1 + x1  
  POL(if_minus(x1, x2, x3))=  x1 + x2 + x3  
  POL(le)=  0  

resulting in one new DP problem.
Used Argument Filtering System:
IFMOD(x1, x2, x3) -> IFMOD(x1, x2, x3)
MOD(x1, x2) -> MOD(x1, x2)
s(x1) -> s(x1)
minus(x1, x2) -> minus(x1, x2)
ifminus(x1, x2, x3) -> ifminus(x1, x2, x3)
le(x1, x2) -> le


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 19
Nar
             ...
               →DP Problem 27
Dependency Graph


Dependency Pair:

MOD(s(s(x''''')), s(0)) -> IFMOD(true, s(s(x''''')), s(0))


Rules:


le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(x, y))
mod(0, y) -> 0
mod(s(x), 0) -> 0
mod(s(x), s(y)) -> ifmod(le(y, x), s(x), s(y))
ifmod(true, s(x), s(y)) -> mod(minus(x, y), s(y))
ifmod(false, s(x), s(y)) -> s(x)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

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