YES
The TRS could be proven terminating. The proof took 1637 ms.
The following DP Processors were used
Problem 1 was processed with processor DependencyGraph (200ms).
| – Problem 2 was processed with processor SubtermCriterion (2ms).
| | – Problem 8 was processed with processor DependencyGraph (0ms).
| – Problem 3 was processed with processor PolynomialLinearRange4iUR (325ms).
| | – Problem 9 was processed with processor DependencyGraph (1ms).
| – Problem 4 was processed with processor SubtermCriterion (2ms).
| – Problem 5 was processed with processor SubtermCriterion (3ms).
| – Problem 6 was processed with processor PolynomialLinearRange4iUR (764ms).
| | – Problem 10 was processed with processor PolynomialLinearRange4iUR (264ms).
| | | – Problem 11 was processed with processor DependencyGraph (0ms).
| – Problem 7 was processed with processor SubtermCriterion (1ms).
Problem 1: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| min#(add(n, add(m, x))) | → | le#(n, m) | | app#(add(n, x), y) | → | app#(x, y) |
| rm#(n, add(m, x)) | → | eq#(n, m) | | if_rm#(false, n, add(m, x)) | → | rm#(n, x) |
| minsort#(add(n, x), y) | → | eq#(n, min(add(n, x))) | | if_minsort#(true, add(n, x), y) | → | rm#(n, x) |
| minsort#(add(n, x), y) | → | min#(add(n, x)) | | min#(add(n, add(m, x))) | → | if_min#(le(n, m), add(n, add(m, x))) |
| if_rm#(true, n, add(m, x)) | → | rm#(n, x) | | if_minsort#(true, add(n, x), y) | → | app#(rm(n, x), y) |
| le#(s(x), s(y)) | → | le#(x, y) | | if_minsort#(true, add(n, x), y) | → | minsort#(app(rm(n, x), y), nil) |
| if_min#(false, add(n, add(m, x))) | → | min#(add(m, x)) | | minsort#(add(n, x), y) | → | if_minsort#(eq(n, min(add(n, x))), add(n, x), y) |
| rm#(n, add(m, x)) | → | if_rm#(eq(n, m), n, add(m, x)) | | eq#(s(x), s(y)) | → | eq#(x, y) |
| if_min#(true, add(n, add(m, x))) | → | min#(add(n, x)) | | if_minsort#(false, add(n, x), y) | → | minsort#(x, add(n, y)) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
The following SCCs where found
| if_minsort#(true, add(n, x), y) → minsort#(app(rm(n, x), y), nil) | minsort#(add(n, x), y) → if_minsort#(eq(n, min(add(n, x))), add(n, x), y) |
| if_minsort#(false, add(n, x), y) → minsort#(x, add(n, y)) |
| le#(s(x), s(y)) → le#(x, y) |
| if_min#(false, add(n, add(m, x))) → min#(add(m, x)) | min#(add(n, add(m, x))) → if_min#(le(n, m), add(n, add(m, x))) |
| if_min#(true, add(n, add(m, x))) → min#(add(n, x)) |
| app#(add(n, x), y) → app#(x, y) |
| if_rm#(false, n, add(m, x)) → rm#(n, x) | rm#(n, add(m, x)) → if_rm#(eq(n, m), n, add(m, x)) |
| if_rm#(true, n, add(m, x)) → rm#(n, x) |
| eq#(s(x), s(y)) → eq#(x, y) |
Problem 2: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| if_rm#(false, n, add(m, x)) | → | rm#(n, x) | | rm#(n, add(m, x)) | → | if_rm#(eq(n, m), n, add(m, x)) |
| if_rm#(true, n, add(m, x)) | → | rm#(n, x) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| if_rm#(false, n, add(m, x)) | → | rm#(n, x) | | if_rm#(true, n, add(m, x)) | → | rm#(n, x) |
Problem 8: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| rm#(n, add(m, x)) | → | if_rm#(eq(n, m), n, add(m, x)) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, eq, nil
Strategy
There are no SCCs!
Problem 3: PolynomialLinearRange4iUR
Dependency Pair Problem
Dependency Pairs
| if_min#(false, add(n, add(m, x))) | → | min#(add(m, x)) | | min#(add(n, add(m, x))) | → | if_min#(le(n, m), add(n, add(m, x))) |
| if_min#(true, add(n, add(m, x))) | → | min#(add(n, x)) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
Polynomial Interpretation
- 0: 1
- add(x,y): y + 1
- app(x,y): 0
- eq(x,y): 0
- false: 0
- if_min(x,y): 0
- if_min#(x,y): y
- if_minsort(x,y,z): 0
- if_rm(x,y,z): 0
- le(x,y): 2y + 2x
- min(x): 0
- min#(x): x + 1
- minsort(x,y): 0
- nil: 0
- rm(x,y): 0
- s(x): x
- true: 0
Improved Usable rules
The following dependency pairs are strictly oriented by an ordering on the given polynomial interpretation, thus they are removed:
| min#(add(n, add(m, x))) | → | if_min#(le(n, m), add(n, add(m, x))) |
Problem 9: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| if_min#(false, add(n, add(m, x))) | → | min#(add(m, x)) | | if_min#(true, add(n, add(m, x))) | → | min#(add(n, x)) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, eq, nil
Strategy
There are no SCCs!
Problem 4: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| app#(add(n, x), y) | → | app#(x, y) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| app#(add(n, x), y) | → | app#(x, y) |
Problem 5: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| eq#(s(x), s(y)) | → | eq#(x, y) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| eq#(s(x), s(y)) | → | eq#(x, y) |
Problem 6: PolynomialLinearRange4iUR
Dependency Pair Problem
Dependency Pairs
| if_minsort#(true, add(n, x), y) | → | minsort#(app(rm(n, x), y), nil) | | minsort#(add(n, x), y) | → | if_minsort#(eq(n, min(add(n, x))), add(n, x), y) |
| if_minsort#(false, add(n, x), y) | → | minsort#(x, add(n, y)) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
Polynomial Interpretation
- 0: 1
- add(x,y): y + 1
- app(x,y): y + x
- eq(x,y): y + x
- false: 0
- if_min(x,y): 2x
- if_minsort(x,y,z): 0
- if_minsort#(x,y,z): 2z + 2y
- if_rm(x,y,z): z
- le(x,y): y
- min(x): 2
- minsort(x,y): 0
- minsort#(x,y): 2y + 2x
- nil: 0
- rm(x,y): y
- s(x): 1
- true: 0
Improved Usable rules
| app(nil, y) | → | y | | if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) |
| if_rm(true, n, add(m, x)) | → | rm(n, x) | | rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) |
| rm(n, nil) | → | nil | | app(add(n, x), y) | → | add(n, app(x, y)) |
The following dependency pairs are strictly oriented by an ordering on the given polynomial interpretation, thus they are removed:
| if_minsort#(true, add(n, x), y) | → | minsort#(app(rm(n, x), y), nil) |
Problem 10: PolynomialLinearRange4iUR
Dependency Pair Problem
Dependency Pairs
| minsort#(add(n, x), y) | → | if_minsort#(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort#(false, add(n, x), y) | → | minsort#(x, add(n, y)) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, eq, nil
Strategy
Polynomial Interpretation
- 0: 0
- add(x,y): y + 1
- app(x,y): 0
- eq(x,y): 0
- false: 0
- if_min(x,y): 3x
- if_minsort(x,y,z): 0
- if_minsort#(x,y,z): 2y
- if_rm(x,y,z): 0
- le(x,y): x + 1
- min(x): 0
- minsort(x,y): 0
- minsort#(x,y): 2x
- nil: 0
- rm(x,y): 0
- s(x): 2
- true: 0
Improved Usable rules
The following dependency pairs are strictly oriented by an ordering on the given polynomial interpretation, thus they are removed:
| if_minsort#(false, add(n, x), y) | → | minsort#(x, add(n, y)) |
Problem 11: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| minsort#(add(n, x), y) | → | if_minsort#(eq(n, min(add(n, x))), add(n, x), y) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
There are no SCCs!
Problem 7: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| le#(s(x), s(y)) | → | le#(x, y) |
Rewrite Rules
| eq(0, 0) | → | true | | eq(0, s(x)) | → | false |
| eq(s(x), 0) | → | false | | eq(s(x), s(y)) | → | eq(x, y) |
| le(0, y) | → | true | | le(s(x), 0) | → | false |
| le(s(x), s(y)) | → | le(x, y) | | app(nil, y) | → | y |
| app(add(n, x), y) | → | add(n, app(x, y)) | | min(add(n, nil)) | → | n |
| min(add(n, add(m, x))) | → | if_min(le(n, m), add(n, add(m, x))) | | if_min(true, add(n, add(m, x))) | → | min(add(n, x)) |
| if_min(false, add(n, add(m, x))) | → | min(add(m, x)) | | rm(n, nil) | → | nil |
| rm(n, add(m, x)) | → | if_rm(eq(n, m), n, add(m, x)) | | if_rm(true, n, add(m, x)) | → | rm(n, x) |
| if_rm(false, n, add(m, x)) | → | add(m, rm(n, x)) | | minsort(nil, nil) | → | nil |
| minsort(add(n, x), y) | → | if_minsort(eq(n, min(add(n, x))), add(n, x), y) | | if_minsort(true, add(n, x), y) | → | add(n, minsort(app(rm(n, x), y), nil)) |
| if_minsort(false, add(n, x), y) | → | minsort(x, add(n, y)) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, add, if_min, 0, if_minsort, s, le, false, if_rm, nil, eq
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| le#(s(x), s(y)) | → | le#(x, y) |