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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))

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)
QUOT(s(x), s(y)) -> QUOT(minus(x, y), s(y))
QUOT(s(x), s(y)) -> MINUS(x, y)
LOG(s(s(x))) -> LOG(s(quot(x, s(s(0)))))
LOG(s(s(x))) -> QUOT(x, s(s(0)))

Furthermore, R contains four SCCs.


   R
DPs
       →DP Problem 1
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 5
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 5
FwdInst
             ...
               →DP Problem 6
Argument Filtering and Ordering
       →DP Problem 2
Nar
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


There are no usable rules for innermost that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(LE(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 5
FwdInst
             ...
               →DP Problem 7
Dependency Graph
       →DP Problem 2
Nar
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Narrowing Transformation
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Nar
             ...
               →DP Problem 9
Instantiation Transformation
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Nar
             ...
               →DP Problem 10
Forward Instantiation Transformation
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Nar
             ...
               →DP Problem 13
Argument Filtering and Ordering
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 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 8
Nar
             ...
               →DP Problem 17
Dependency Graph
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 8
Nar
             ...
               →DP Problem 11
Forward Instantiation Transformation
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Nar
             ...
               →DP Problem 14
Argument Filtering and Ordering
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 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 8
Nar
             ...
               →DP Problem 18
Dependency Graph
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 8
Nar
             ...
               →DP Problem 12
Forward Instantiation Transformation
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Nar
             ...
               →DP Problem 15
Forward Instantiation Transformation
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 8
Nar
             ...
               →DP Problem 16
Argument Filtering and Ordering
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 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 8
Nar
             ...
               →DP Problem 19
Dependency Graph
       →DP Problem 3
Nar
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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
       →DP Problem 4
Nar


Dependency Pair:

QUOT(s(x), s(y)) -> QUOT(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

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

QUOT(s(0), s(y'')) -> QUOT(0, s(y''))
QUOT(s(s(x'')), s(y'')) -> QUOT(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 20
Narrowing Transformation
       →DP Problem 4
Nar


Dependency Pair:

QUOT(s(s(x'')), s(y'')) -> QUOT(ifminus(le(s(x''), y''), s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

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

QUOT(s(s(x''')), s(0)) -> QUOT(ifminus(false, s(x'''), 0), s(0))
QUOT(s(s(x''')), s(s(y'))) -> QUOT(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 20
Nar
             ...
               →DP Problem 21
Rewriting Transformation
       →DP Problem 4
Nar


Dependency Pair:

QUOT(s(s(x''')), s(0)) -> QUOT(ifminus(false, s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

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

QUOT(s(s(x''')), s(0)) -> QUOT(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 20
Nar
             ...
               →DP Problem 23
Argument Filtering and Ordering
       →DP Problem 4
Nar


Dependency Pair:

QUOT(s(s(x''')), s(0)) -> QUOT(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




The following dependency pair can be strictly oriented:

QUOT(s(s(x''')), s(0)) -> QUOT(s(minus(x''', 0)), s(0))


The following usable rules for innermost 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(QUOT(x1, x2))=  1 + x1 + x2  
  POL(0)=  0  
  POL(false)=  0  
  POL(minus(x1, x2))=  x1 + x2  
  POL(true)=  0  
  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:
QUOT(x1, x2) -> QUOT(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 20
Nar
             ...
               →DP Problem 22
Argument Filtering and Ordering
       →DP Problem 4
Nar


Dependency Pair:

QUOT(s(s(x''')), s(s(y'))) -> QUOT(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




The following dependency pair can be strictly oriented:

QUOT(s(s(x''')), s(s(y'))) -> QUOT(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))


The following usable rules for innermost can be oriented:

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)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)


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

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


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
       →DP Problem 3
Nar
           →DP Problem 20
Nar
             ...
               →DP Problem 24
Dependency Graph
       →DP Problem 4
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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


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 4
Narrowing Transformation


Dependency Pair:

LOG(s(s(x))) -> LOG(s(quot(x, s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

LOG(s(s(x))) -> LOG(s(quot(x, s(s(0)))))
two new Dependency Pairs are created:

LOG(s(s(0))) -> LOG(s(0))
LOG(s(s(s(x'')))) -> LOG(s(s(quot(minus(x'', s(0)), s(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 4
Nar
           →DP Problem 26
Narrowing Transformation


Dependency Pair:

LOG(s(s(s(x'')))) -> LOG(s(s(quot(minus(x'', s(0)), s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

LOG(s(s(s(x'')))) -> LOG(s(s(quot(minus(x'', s(0)), s(s(0))))))
two new Dependency Pairs are created:

LOG(s(s(s(0)))) -> LOG(s(s(quot(0, s(s(0))))))
LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(s(x'), s(0)), s(x'), s(0)), s(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 4
Nar
           →DP Problem 26
Nar
             ...
               →DP Problem 27
Rewriting Transformation


Dependency Pairs:

LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(s(x'), s(0)), s(x'), s(0)), s(s(0))))))
LOG(s(s(s(0)))) -> LOG(s(s(quot(0, s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

LOG(s(s(s(0)))) -> LOG(s(s(quot(0, s(s(0))))))
one new Dependency Pair is created:

LOG(s(s(s(0)))) -> LOG(s(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 4
Nar
           →DP Problem 26
Nar
             ...
               →DP Problem 28
Rewriting Transformation


Dependency Pair:

LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(s(x'), s(0)), s(x'), s(0)), s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




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

LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(s(x'), s(0)), s(x'), s(0)), s(s(0))))))
one new Dependency Pair is created:

LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(x', 0), s(x'), s(0)), s(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 4
Nar
           →DP Problem 26
Nar
             ...
               →DP Problem 29
Argument Filtering and Ordering


Dependency Pair:

LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(x', 0), s(x'), s(0)), s(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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




The following dependency pair can be strictly oriented:

LOG(s(s(s(s(x'))))) -> LOG(s(s(quot(ifminus(le(x', 0), s(x'), s(0)), s(s(0))))))


The following usable rules for innermost can be oriented:

quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(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)
minus(0, y) -> 0
minus(s(x), y) -> ifminus(le(s(x), y), s(x), y)


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

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


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


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))
quot(0, s(y)) -> 0
quot(s(x), s(y)) -> s(quot(minus(x, y), s(y)))
log(s(0)) -> 0
log(s(s(x))) -> s(log(s(quot(x, s(s(0))))))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

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