Termination Proof using AProVE

Term Rewriting System R:
[x, y, z, k, l]
app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

APP'(app'(minus, app'(s, x)), app'(s, y)) -> APP'(app'(minus, x), y)
APP'(app'(minus, app'(s, x)), app'(s, y)) -> APP'(minus, x)
APP'(app'(minus, app'(app'(minus, x), y)), z) -> APP'(app'(minus, x), app'(app'(plus, y), z))
APP'(app'(minus, app'(app'(minus, x), y)), z) -> APP'(app'(plus, y), z)
APP'(app'(minus, app'(app'(minus, x), y)), z) -> APP'(plus, y)
APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))
APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(quot, app'(app'(minus, x), y))
APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(app'(minus, x), y)
APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(minus, x)
APP'(app'(plus, app'(s, x)), y) -> APP'(s, app'(app'(plus, x), y))
APP'(app'(plus, app'(s, x)), y) -> APP'(app'(plus, x), y)
APP'(app'(plus, app'(s, x)), y) -> APP'(plus, x)
APP'(app'(app, app'(app'(cons, x), l)), k) -> APP'(app'(cons, x), app'(app'(app, l), k))
APP'(app'(app, app'(app'(cons, x), l)), k) -> APP'(app'(app, l), k)
APP'(app'(app, app'(app'(cons, x), l)), k) -> APP'(app, l)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(app'(cons, app'(app'(plus, x), y)), l)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(cons, app'(app'(plus, x), y))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(app'(plus, x), y)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(plus, x)
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> APP'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k))))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> APP'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))

Furthermore, R contains six SCCs.

     ↳DPs

       →DP Problem 1

         ↳Usable Rules (Innermost)

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(app'(plus, app'(s, x)), y) -> APP'(app'(plus, x), y)

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Strategy:

innermost

As we are in the innermost case, we can delete all 13 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

           →DP Problem 7

             ↳A-Transformation

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(app'(plus, app'(s, x)), y) -> APP'(app'(plus, x), y)

Rule:

none

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

           →DP Problem 7

             ↳ATrans

...

               →DP Problem 8

                 ↳Size-Change Principle

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

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

Rule:

none

Strategy:

innermost

We number the DPs as follows:

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

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1
2	=	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	>	1
2	=	2

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

s(x₁) -> s(x₁)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳Usable Rules (Innermost)

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(app'(app, app'(app'(cons, x), l)), k) -> APP'(app'(app, l), k)

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Strategy:

innermost

As we are in the innermost case, we can delete all 13 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

           →DP Problem 9

             ↳A-Transformation

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(app'(app, app'(app'(cons, x), l)), k) -> APP'(app'(app, l), k)

Rule:

none

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

           →DP Problem 9

             ↳ATrans

...

               →DP Problem 10

                 ↳Size-Change Principle

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP(cons(x, l), k) -> APP(l, k)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

APP(cons(x, l), k) -> APP(l, k)

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1
2	=	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	>	1
2	=	2

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

cons(x₁, x₂) -> cons(x₁, x₂)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳Usable Rules (Innermost)

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pairs:

APP'(app'(minus, app'(app'(minus, x), y)), z) -> APP'(app'(minus, x), app'(app'(plus, y), z))
APP'(app'(minus, app'(s, x)), app'(s, y)) -> APP'(app'(minus, x), y)

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Strategy:

innermost

As we are in the innermost case, we can delete all 11 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

           →DP Problem 11

             ↳A-Transformation

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pairs:

APP'(app'(minus, app'(app'(minus, x), y)), z) -> APP'(app'(minus, x), app'(app'(plus, y), z))
APP'(app'(minus, app'(s, x)), app'(s, y)) -> APP'(app'(minus, x), y)

Rules:

app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

           →DP Problem 11

             ↳ATrans

...

               →DP Problem 12

                 ↳Size-Change Principle

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pairs:

MINUS(minus(x, y), z) -> MINUS(x, plus(y, z))
MINUS(s(x), s(y)) -> MINUS(x, y)

Rules:

plus(0, y) -> y
plus(s(x), y) -> s(plus(x, y))

Strategy:

innermost

We number the DPs as follows:

MINUS(minus(x, y), z) -> MINUS(x, plus(y, z))
MINUS(s(x), s(y)) -> MINUS(x, y)

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1

{2}	,	{2}
1	>	1
2	>	2

which lead(s) to this/these maximal multigraph(s):

{2}	,	{2}
1	>	1
2	>	2

{2}	,	{1}
1	>	1

{1}	,	{2}
1	>	1

{2}	,	{2}
1	>	1

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

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

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳Usable Rules (Innermost)

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Strategy:

innermost

As we are in the innermost case, we can delete all 11 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 13

             ↳A-Transformation

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))

Rules:

app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 13

             ↳ATrans

...

               →DP Problem 14

                 ↳Modular Removal of Rules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

SUM(cons(x, cons(y, l))) -> SUM(cons(plus(x, y), l))

Rules:

plus(0, y) -> y
plus(s(x), y) -> s(plus(x, y))

Strategy:

innermost

We have the following set of usable rules:

plus(s(x), y) -> s(plus(x, y))
plus(0, y) -> y

To remove rules and DPs from this DP problem we used the following monotonic and C_E-compatible order: Polynomial ordering.
Polynomial interpretation:

POL(plus(x₁, x₂)) = x₁ + x₂

POL(SUM(x₁)) = 1 + x₁

POL(0) = 1

POL(cons(x₁, x₂)) = x₁ + x₂

POL(s(x₁)) = x₁

We have the following set D of usable symbols: {plus, SUM, cons, s}
No Dependency Pairs can be deleted.
The following rules can be deleted as they contain symbols in their lhs which do not occur in D:

plus(0, y) -> y

The result of this processor delivers one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 13

             ↳ATrans

...

               →DP Problem 15

                 ↳Modular Removal of Rules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

SUM(cons(x, cons(y, l))) -> SUM(cons(plus(x, y), l))

Rule:

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

Strategy:

innermost

We have the following set of usable rules:

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

To remove rules and DPs from this DP problem we used the following monotonic and C_E-compatible order: Polynomial ordering.
Polynomial interpretation:

POL(plus(x₁, x₂)) = x₁ + x₂

POL(SUM(x₁)) = 1 + x₁

POL(cons(x₁, x₂)) = 1 + x₁ + x₂

POL(s(x₁)) = x₁

We have the following set D of usable symbols: {plus, SUM, cons, s}
The following Dependency Pairs can be deleted as the lhs is strictly greater than the corresponding rhs:

SUM(cons(x, cons(y, l))) -> SUM(cons(plus(x, y), l))

No Rules can be deleted.

After the removal, there are no SCCs in the dependency graph which results in no DP problems which have to be solved.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳Usable Rules (Innermost)

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Strategy:

innermost

As we are in the innermost case, we can delete all 8 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

           →DP Problem 16

             ↳A-Transformation

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

APP'(app'(quot, app'(s, x)), app'(s, y)) -> APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(plus, 0), y) -> y
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

           →DP Problem 16

             ↳ATrans

...

               →DP Problem 17

                 ↳Negative Polynomial Order

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

QUOT(s(x), s(y)) -> QUOT(minus(x, y), s(y))

Rules:

minus(x, 0) -> x
minus(minus(x, y), z) -> minus(x, plus(y, z))
minus(s(x), s(y)) -> minus(x, y)
plus(0, y) -> y
plus(s(x), y) -> s(plus(x, y))

Strategy:

innermost

The following Dependency Pair can be strictly oriented using the given order.

QUOT(s(x), s(y)) -> QUOT(minus(x, y), s(y))

Moreover, the following usable rules (regarding the implicit AFS) are oriented.

minus(s(x), s(y)) -> minus(x, y)
plus(s(x), y) -> s(plus(x, y))
minus(x, 0) -> x
minus(minus(x, y), z) -> minus(x, plus(y, z))
plus(0, y) -> y

Used ordering:
Polynomial Order with Interpretation:

POL( QUOT(x₁, x₂) ) = x₁

POL( s(x₁) ) = x₁ + 1

POL( minus(x₁, x₂) ) = x₁

POL( plus(x₁, x₂) ) = x₁ + x₂

This results in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

           →DP Problem 16

             ↳ATrans

...

               →DP Problem 18

                 ↳Dependency Graph

       →DP Problem 6

         ↳UsableRules

Dependency Pair:

Rules:

minus(x, 0) -> x
minus(minus(x, y), z) -> minus(x, plus(y, z))
minus(s(x), s(y)) -> minus(x, y)
plus(0, y) -> y
plus(s(x), y) -> s(plus(x, y))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳Usable Rules (Innermost)

Dependency Pair:

APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Rules:

app'(app'(minus, x), 0) -> x
app'(app'(minus, app'(s, x)), app'(s, y)) -> app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) -> app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) -> 0
app'(app'(quot, app'(s, x)), app'(s, y)) -> app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) -> y
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) -> k
app'(app'(app, l), nil) -> l
app'(app'(app, app'(app'(cons, x), l)), k) -> app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Strategy:

innermost

As we are in the innermost case, we can delete all 8 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

           →DP Problem 19

             ↳A-Transformation

Dependency Pair:

APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) -> APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

Rules:

app'(app'(plus, 0), y) -> y
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) -> app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(app'(app, l), nil) -> l
app'(sum, app'(app'(cons, x), nil)) -> app'(app'(cons, x), nil)
app'(app'(plus, app'(s, x)), y) -> app'(s, app'(app'(plus, x), y))

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

           →DP Problem 19

             ↳ATrans

...

               →DP Problem 20

                 ↳Modular Removal of Rules

Dependency Pair:

SUM(app(l, cons(x, cons(y, k)))) -> SUM(app(l, sum(cons(x, cons(y, k)))))

Rules:

plus(0, y) -> y
plus(s(x), y) -> s(plus(x, y))
sum(cons(x, cons(y, l))) -> sum(cons(plus(x, y), l))
sum(cons(x, nil)) -> cons(x, nil)
app(l, nil) -> l

Strategy:

innermost

We have the following set of usable rules:

app(l, nil) -> l
sum(cons(x, nil)) -> cons(x, nil)
plus(s(x), y) -> s(plus(x, y))
sum(cons(x, cons(y, l))) -> sum(cons(plus(x, y), l))
plus(0, y) -> y

To remove rules and DPs from this DP problem we used the following monotonic and C_E-compatible order: Polynomial ordering.
Polynomial interpretation:

POL(plus(x₁, x₂)) = x₁ + x₂

POL(SUM(x₁)) = 1 + x₁

POL(0) = 1

POL(cons(x₁, x₂)) = x₁ + x₂

POL(nil) = 0

POL(sum(x₁)) = x₁

POL(s(x₁)) = x₁

POL(app(x₁, x₂)) = 1 + x₁ + x₂

We have the following set D of usable symbols: {plus, SUM, cons, nil, sum, s, app}
No Dependency Pairs can be deleted.
The following rules can be deleted as they contain symbols in their lhs which do not occur in D:

plus(0, y) -> y

The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

app(l, nil) -> l

The result of this processor delivers one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

           →DP Problem 19

             ↳ATrans

...

               →DP Problem 21

                 ↳Modular Removal of Rules

Dependency Pair:

SUM(app(l, cons(x, cons(y, k)))) -> SUM(app(l, sum(cons(x, cons(y, k)))))

Rules:

sum(cons(x, nil)) -> cons(x, nil)
sum(cons(x, cons(y, l))) -> sum(cons(plus(x, y), l))
plus(s(x), y) -> s(plus(x, y))

Strategy:

innermost

We have the following set of usable rules:

sum(cons(x, nil)) -> cons(x, nil)
plus(s(x), y) -> s(plus(x, y))
sum(cons(x, cons(y, l))) -> sum(cons(plus(x, y), l))

To remove rules and DPs from this DP problem we used the following monotonic and C_E-compatible order: Polynomial ordering.
Polynomial interpretation:

POL(plus(x₁, x₂)) = x₁ + x₂

POL(SUM(x₁)) = 1 + x₁

POL(cons(x₁, x₂)) = 1 + x₁ + x₂

POL(nil) = 0

POL(sum(x₁)) = x₁

POL(s(x₁)) = x₁

POL(app(x₁, x₂)) = 1 + x₁ + x₂

We have the following set D of usable symbols: {plus, SUM, cons, nil, sum, s, app}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

sum(cons(x, cons(y, l))) -> sum(cons(plus(x, y), l))

The result of this processor delivers one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

           →DP Problem 19

             ↳ATrans

...

               →DP Problem 22

                 ↳Modular Removal of Rules

Dependency Pair:

SUM(app(l, cons(x, cons(y, k)))) -> SUM(app(l, sum(cons(x, cons(y, k)))))

Rules:

sum(cons(x, nil)) -> cons(x, nil)
plus(s(x), y) -> s(plus(x, y))

Strategy:

innermost

We have the following set of usable rules: none
To remove rules and DPs from this DP problem we used the following monotonic and C_E-compatible order: Polynomial ordering.
Polynomial interpretation:

POL(SUM(x₁)) = 1 + x₁

POL(cons(x₁, x₂)) = x₁ + x₂

POL(sum(x₁)) = x₁

POL(app(x₁, x₂)) = 1 + x₁ + x₂

We have the following set D of usable symbols: {SUM, cons, sum, app}
No Dependency Pairs can be deleted.
2 non usable rules have been deleted.

The result of this processor delivers one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

           →DP Problem 19

             ↳ATrans

...

               →DP Problem 23

                 ↳Dependency Graph

Dependency Pair:

SUM(app(l, cons(x, cons(y, k)))) -> SUM(app(l, sum(cons(x, cons(y, k)))))

Rule:

none

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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

POL(plus(x₁, x₂))	= x₁ + x₂
POL(SUM(x₁))	= 1 + x₁
POL(0)	= 1
POL(cons(x₁, x₂))	= x₁ + x₂
POL(s(x₁))	= x₁