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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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)
GCD(s(x), s(y)) -> IFGCD(le(y, x), s(x), s(y))
GCD(s(x), s(y)) -> LE(y, x)
IFGCD(true, s(x), s(y)) -> GCD(minus(x, y), s(y))
IFGCD(true, s(x), s(y)) -> MINUS(x, y)
IFGCD(false, s(x), s(y)) -> GCD(minus(y, x), s(x))
IFGCD(false, s(x), s(y)) -> MINUS(y, x)

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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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
Polynomial 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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 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 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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
Polynomial 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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'''')))


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

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


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

resulting in one new DP problem.



   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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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
Polynomial 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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 that need to be oriented.

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

resulting in one new DP problem.



   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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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
Polynomial 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




The following dependency pair can be strictly oriented:

IFMINUS(false, s(s(x'''')), 0) -> MINUS(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))=  x2  
  POL(0)=  0  
  POL(false)=  0  
  POL(MINUS(x1, x2))=  x1  
  POL(s(x1))=  1 + x1  

resulting in one new DP problem.



   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:

MINUS(s(s(x'''''')), 0) -> IFMINUS(false, s(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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:

IFGCD(false, s(x), s(y)) -> GCD(minus(y, x), s(x))
IFGCD(true, s(x), s(y)) -> GCD(minus(x, y), s(y))
GCD(s(x), s(y)) -> IFGCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

GCD(s(x'), s(0)) -> IFGCD(true, s(x'), s(0))
GCD(s(0), s(s(x''))) -> IFGCD(false, s(0), s(s(x'')))
GCD(s(s(y'')), s(s(x''))) -> IFGCD(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:

GCD(s(s(y'')), s(s(x''))) -> IFGCD(le(x'', y''), s(s(y'')), s(s(x'')))
GCD(s(0), s(s(x''))) -> IFGCD(false, s(0), s(s(x'')))
IFGCD(true, s(x), s(y)) -> GCD(minus(x, y), s(y))
GCD(s(x'), s(0)) -> IFGCD(true, s(x'), s(0))
IFGCD(false, s(x), s(y)) -> GCD(minus(y, x), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

IFGCD(true, s(0), s(y'')) -> GCD(0, s(y''))
IFGCD(true, s(s(x'')), s(y'')) -> GCD(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:

GCD(s(0), s(s(x''))) -> IFGCD(false, s(0), s(s(x'')))
IFGCD(true, s(s(x'')), s(y'')) -> GCD(ifminus(le(s(x''), y''), s(x''), y''), s(y''))
GCD(s(x'), s(0)) -> IFGCD(true, s(x'), s(0))
IFGCD(false, s(x), s(y)) -> GCD(minus(y, x), s(x))
GCD(s(s(y'')), s(s(x''))) -> IFGCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

IFGCD(false, s(x'), s(0)) -> GCD(0, s(x'))
IFGCD(false, s(x0), s(s(x''))) -> GCD(ifminus(le(s(x''), x0), s(x''), x0), s(x0))

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:

GCD(s(s(y'')), s(s(x''))) -> IFGCD(le(x'', y''), s(s(y'')), s(s(x'')))
IFGCD(true, s(s(x'')), s(y'')) -> GCD(ifminus(le(s(x''), y''), s(x''), y''), s(y''))
GCD(s(x'), s(0)) -> IFGCD(true, s(x'), s(0))
IFGCD(false, s(x0), s(s(x''))) -> GCD(ifminus(le(s(x''), x0), s(x''), x0), s(x0))
GCD(s(0), s(s(x''))) -> IFGCD(false, s(0), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

GCD(s(s(y''')), s(s(0))) -> IFGCD(true, s(s(y''')), s(s(0)))
GCD(s(s(0)), s(s(s(x')))) -> IFGCD(false, s(s(0)), s(s(s(x'))))
GCD(s(s(s(y'))), s(s(s(x')))) -> IFGCD(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 22
Narrowing Transformation


Dependency Pairs:

GCD(s(s(s(y'))), s(s(s(x')))) -> IFGCD(le(x', y'), s(s(s(y'))), s(s(s(x'))))
GCD(s(s(0)), s(s(s(x')))) -> IFGCD(false, s(s(0)), s(s(s(x'))))
GCD(s(s(y''')), s(s(0))) -> IFGCD(true, s(s(y''')), s(s(0)))
IFGCD(false, s(x0), s(s(x''))) -> GCD(ifminus(le(s(x''), x0), s(x''), x0), s(x0))
GCD(s(0), s(s(x''))) -> IFGCD(false, s(0), s(s(x'')))
GCD(s(x'), s(0)) -> IFGCD(true, s(x'), s(0))
IFGCD(true, s(s(x'')), s(y'')) -> GCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

IFGCD(true, s(s(x''')), s(0)) -> GCD(ifminus(false, s(x'''), 0), s(0))
IFGCD(true, s(s(x''')), s(s(y'))) -> GCD(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 23
Rewriting Transformation


Dependency Pairs:

IFGCD(true, s(s(x''')), s(0)) -> GCD(ifminus(false, s(x'''), 0), s(0))
GCD(s(x'), s(0)) -> IFGCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

IFGCD(true, s(s(x''')), s(0)) -> GCD(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 25
Forward Instantiation Transformation


Dependency Pairs:

IFGCD(true, s(s(x''')), s(0)) -> GCD(s(minus(x''', 0)), s(0))
GCD(s(x'), s(0)) -> IFGCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

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

GCD(s(s(x''''')), s(0)) -> IFGCD(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 27
Polynomial Ordering


Dependency Pairs:

GCD(s(s(x''''')), s(0)) -> IFGCD(true, s(s(x''''')), s(0))
IFGCD(true, s(s(x''')), s(0)) -> GCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




The following dependency pair can be strictly oriented:

IFGCD(true, s(s(x''')), s(0)) -> GCD(s(minus(x''', 0)), s(0))


Additionally, 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(0)=  0  
  POL(GCD(x1, x2))=  x1  
  POL(false)=  0  
  POL(minus(x1, x2))=  x1  
  POL(true)=  0  
  POL(IF_GCD(x1, x2, x3))=  x2  
  POL(s(x1))=  1 + x1  
  POL(if_minus(x1, x2, x3))=  x2  
  POL(le(x1, x2))=  0  

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 29
Dependency Graph


Dependency Pair:

GCD(s(s(x''''')), s(0)) -> IFGCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), 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 24
Narrowing Transformation


Dependency Pairs:

GCD(s(s(0)), s(s(s(x')))) -> IFGCD(false, s(s(0)), s(s(s(x'))))
IFGCD(true, s(s(x''')), s(s(y'))) -> GCD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))
GCD(s(s(y''')), s(s(0))) -> IFGCD(true, s(s(y''')), s(s(0)))
GCD(s(0), s(s(x''))) -> IFGCD(false, s(0), s(s(x'')))
IFGCD(false, s(x0), s(s(x''))) -> GCD(ifminus(le(s(x''), x0), s(x''), x0), s(x0))
GCD(s(s(s(y'))), s(s(s(x')))) -> IFGCD(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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




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

IFGCD(false, s(x0), s(s(x''))) -> GCD(ifminus(le(s(x''), x0), s(x''), x0), s(x0))
two new Dependency Pairs are created:

IFGCD(false, s(0), s(s(x'''))) -> GCD(ifminus(false, s(x'''), 0), s(0))
IFGCD(false, s(s(y')), s(s(x'''))) -> GCD(ifminus(le(x''', y'), s(x'''), s(y')), s(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 26
Polynomial Ordering


Dependency Pairs:

GCD(s(s(s(y'))), s(s(s(x')))) -> IFGCD(le(x', y'), s(s(s(y'))), s(s(s(x'))))
IFGCD(true, s(s(x''')), s(s(y'))) -> GCD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))
GCD(s(s(y''')), s(s(0))) -> IFGCD(true, s(s(y''')), s(s(0)))
IFGCD(false, s(s(y')), s(s(x'''))) -> GCD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))
GCD(s(s(0)), s(s(s(x')))) -> IFGCD(false, s(s(0)), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

IFGCD(true, s(s(x''')), s(s(y'))) -> GCD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))
IFGCD(false, s(s(y')), s(s(x'''))) -> GCD(ifminus(le(x''', y'), s(x'''), s(y')), s(s(y')))


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

le(0, y) -> true
le(s(x), 0) -> false
le(s(x), s(y)) -> le(x, y)
ifminus(true, s(x), y) -> 0
ifminus(false, s(x), y) -> s(minus(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(GCD(x1, x2))=  x1 + x2  
  POL(false)=  0  
  POL(minus(x1, x2))=  x1  
  POL(true)=  0  
  POL(IF_GCD(x1, x2, x3))=  x2 + x3  
  POL(s(x1))=  1 + x1  
  POL(if_minus(x1, x2, x3))=  x2  
  POL(le(x1, x2))=  0  

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 28
Dependency Graph


Dependency Pairs:

GCD(s(s(s(y'))), s(s(s(x')))) -> IFGCD(le(x', y'), s(s(s(y'))), s(s(s(x'))))
GCD(s(s(y''')), s(s(0))) -> IFGCD(true, s(s(y''')), s(s(0)))
GCD(s(s(0)), s(s(s(x')))) -> IFGCD(false, s(s(0)), 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))
gcd(0, y) -> y
gcd(s(x), 0) -> s(x)
gcd(s(x), s(y)) -> ifgcd(le(y, x), s(x), s(y))
ifgcd(true, s(x), s(y)) -> gcd(minus(x, y), s(y))
ifgcd(false, s(x), s(y)) -> gcd(minus(y, x), s(x))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

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