Termination Proof using AProVE

Term Rewriting System R:
[X, Y]
minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

MINUS(X, s(Y)) -> PRED(minus(X, Y))
MINUS(X, s(Y)) -> MINUS(X, Y)
LE(s(X), s(Y)) -> LE(X, Y)
GCD(s(X), s(Y)) -> IF(le(Y, X), s(X), s(Y))
GCD(s(X), s(Y)) -> LE(Y, X)
IF(true, s(X), s(Y)) -> GCD(minus(X, Y), s(Y))
IF(true, s(X), s(Y)) -> MINUS(X, Y)
IF(false, s(X), s(Y)) -> GCD(minus(Y, X), s(X))
IF(false, s(X), s(Y)) -> MINUS(Y, X)

Furthermore, R contains three SCCs.

     ↳DPs

       →DP Problem 1

         ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

Dependency Pair:

MINUS(X, s(Y)) -> MINUS(X, Y)

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

The following dependency pair can be strictly oriented:

MINUS(X, s(Y)) -> MINUS(X, Y)

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

MINUS(x₁, x₂) -> MINUS(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳AFS

           →DP Problem 4

             ↳Dependency Graph

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

Dependency Pair:

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳Argument Filtering and Ordering

       →DP Problem 3

         ↳Nar

Dependency Pair:

LE(s(X), s(Y)) -> LE(X, Y)

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

The following dependency pair can be strictly oriented:

LE(s(X), s(Y)) -> LE(X, Y)

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

LE(x₁, x₂) -> LE(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

           →DP Problem 5

             ↳Dependency Graph

       →DP Problem 3

         ↳Nar

Dependency Pair:

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Narrowing Transformation

Dependency Pairs:

IF(false, s(X), s(Y)) -> GCD(minus(Y, X), s(X))
IF(true, s(X), s(Y)) -> GCD(minus(X, Y), s(Y))
GCD(s(X), s(Y)) -> IF(le(Y, X), s(X), s(Y))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(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)) -> IF(le(Y, X), s(X), s(Y))

three new Dependency Pairs are created:

GCD(s(s(Y'')), s(s(X''))) -> IF(le(X'', Y''), s(s(Y'')), s(s(X'')))
GCD(s(0), s(s(X''))) -> IF(false, s(0), s(s(X'')))
GCD(s(X'), s(0)) -> IF(true, s(X'), s(0))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Narrowing Transformation

Dependency Pairs:

GCD(s(X'), s(0)) -> IF(true, s(X'), s(0))
GCD(s(0), s(s(X''))) -> IF(false, s(0), s(s(X'')))
IF(true, s(X), s(Y)) -> GCD(minus(X, Y), s(Y))
GCD(s(s(Y'')), s(s(X''))) -> IF(le(X'', Y''), s(s(Y'')), s(s(X'')))
IF(false, s(X), s(Y)) -> GCD(minus(Y, X), s(X))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(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

IF(true, s(X), s(Y)) -> GCD(minus(X, Y), s(Y))

two new Dependency Pairs are created:

IF(true, s(X''), s(s(Y''))) -> GCD(pred(minus(X'', Y'')), s(s(Y'')))
IF(true, s(X''), s(0)) -> GCD(X'', s(0))

The transformation is resulting in two new DP problems:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Nar

...

               →DP Problem 7

                 ↳Argument Filtering and Ordering

Dependency Pairs:

IF(true, s(X''), s(0)) -> GCD(X'', s(0))
GCD(s(X'), s(0)) -> IF(true, s(X'), s(0))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF(true, s(X''), s(0)) -> GCD(X'', s(0))

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

IF(x₁, x₂, x₃) -> x₂
s(x₁) -> s(x₁)
GCD(x₁, x₂) -> x₁

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Nar

...

               →DP Problem 12

                 ↳Dependency Graph

Dependency Pair:

GCD(s(X'), s(0)) -> IF(true, s(X'), s(0))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Nar

...

               →DP Problem 8

                 ↳Narrowing Transformation

Dependency Pairs:

IF(true, s(X''), s(s(Y''))) -> GCD(pred(minus(X'', Y'')), s(s(Y'')))
GCD(s(s(Y'')), s(s(X''))) -> IF(le(X'', Y''), s(s(Y'')), s(s(X'')))
IF(false, s(X), s(Y)) -> GCD(minus(Y, X), s(X))
GCD(s(0), s(s(X''))) -> IF(false, s(0), s(s(X'')))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(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

IF(false, s(X), s(Y)) -> GCD(minus(Y, X), s(X))

two new Dependency Pairs are created:

IF(false, s(s(Y'')), s(Y0)) -> GCD(pred(minus(Y0, Y'')), s(s(Y'')))
IF(false, s(0), s(Y')) -> GCD(Y', s(0))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Nar

...

               →DP Problem 9

                 ↳Instantiation Transformation

Dependency Pairs:

IF(false, s(s(Y'')), s(Y0)) -> GCD(pred(minus(Y0, Y'')), s(s(Y'')))
GCD(s(s(Y'')), s(s(X''))) -> IF(le(X'', Y''), s(s(Y'')), s(s(X'')))
IF(true, s(X''), s(s(Y''))) -> GCD(pred(minus(X'', Y'')), s(s(Y'')))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(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

IF(true, s(X''), s(s(Y''))) -> GCD(pred(minus(X'', Y'')), s(s(Y'')))

one new Dependency Pair is created:

IF(true, s(s(Y''''')), s(s(Y''''))) -> GCD(pred(minus(s(Y'''''), Y'''')), s(s(Y'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Nar

...

               →DP Problem 10

                 ↳Instantiation Transformation

Dependency Pairs:

IF(true, s(s(Y''''')), s(s(Y''''))) -> GCD(pred(minus(s(Y'''''), Y'''')), s(s(Y'''')))
GCD(s(s(Y'')), s(s(X''))) -> IF(le(X'', Y''), s(s(Y'')), s(s(X'')))
IF(false, s(s(Y'')), s(Y0)) -> GCD(pred(minus(Y0, Y'')), s(s(Y'')))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(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

IF(false, s(s(Y'')), s(Y0)) -> GCD(pred(minus(Y0, Y'')), s(s(Y'')))

one new Dependency Pair is created:

IF(false, s(s(Y'''')), s(s(X''''))) -> GCD(pred(minus(s(X''''), Y'''')), s(s(Y'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Nar

           →DP Problem 6

             ↳Nar

...

               →DP Problem 11

                 ↳Remaining Obligation(s)

The following remains to be proven:
Dependency Pairs:

IF(false, s(s(Y'''')), s(s(X''''))) -> GCD(pred(minus(s(X''''), Y'''')), s(s(Y'''')))
GCD(s(s(Y'')), s(s(X''))) -> IF(le(X'', Y''), s(s(Y'')), s(s(X'')))
IF(true, s(s(Y''''')), s(s(Y''''))) -> GCD(pred(minus(s(Y'''''), Y'''')), s(s(Y'''')))

Rules:

minus(X, s(Y)) -> pred(minus(X, Y))
minus(X, 0) -> X
pred(s(X)) -> X
le(s(X), s(Y)) -> le(X, Y)
le(s(X), 0) -> false
le(0, Y) -> true
gcd(0, Y) -> 0
gcd(s(X), 0) -> s(X)
gcd(s(X), s(Y)) -> if(le(Y, X), s(X), s(Y))
if(true, s(X), s(Y)) -> gcd(minus(X, Y), s(Y))
if(false, s(X), s(Y)) -> gcd(minus(Y, X), s(X))

Strategy:

innermost

Innermost Termination of R could not be shown.
Duration:
0:02 minutes