TIMEOUT
The TRS could not be proven terminating. The proof attempt took 60036 ms.
The following DP Processors were used
Problem 1 was processed with processor DependencyGraph (468ms).
| – Problem 2 was processed with processor SubtermCriterion (2ms).
| – Problem 3 was processed with processor SubtermCriterion (1ms).
| | – Problem 8 was processed with processor DependencyGraph (2ms).
| – Problem 4 was processed with processor PolynomialLinearRange4iUR (401ms).
| | – Problem 9 was processed with processor DependencyGraph (1ms).
| – Problem 5 was processed with processor SubtermCriterion (1ms).
| – Problem 6 was processed with processor SubtermCriterion (1ms).
| – Problem 7 remains open; application of the following processors failed [SubtermCriterion (0ms), DependencyGraph (10ms), PolynomialLinearRange4iUR (2802ms), DependencyGraph (10ms), PolynomialLinearRange4iUR (2395ms), DependencyGraph (34ms), PolynomialLinearRange8NegiUR (13348ms), DependencyGraph (10ms), ReductionPairSAT (timeout)].
The following open problems remain:
Open Dependency Pair Problem 7
Dependency Pairs
| if#(false, x, y, z) | → | if2#(eq(head(x), min(x)), x, y, z) | | if2#(true, x, y, z) | → | mins#(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) |
| mins#(x, y, z) | → | if#(null(x), x, y, z) | | if2#(false, x, y, z) | → | mins#(tail(x), add(head(x), y), z) |
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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, if_rm, false, head, null, eq, nil
Problem 1: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| if#(false, x, y, z) | → | if2#(eq(head(x), min(x)), x, y, z) | | min#(add(n, add(m, x))) | → | le#(n, m) |
| if2#(false, x, y, z) | → | head#(x) | | app#(add(n, x), y) | → | app#(x, y) |
| if_rm#(false, n, add(m, x)) | → | rm#(n, x) | | if#(false, x, y, z) | → | eq#(head(x), min(x)) |
| min#(add(n, add(m, x))) | → | if_min#(le(n, m), add(n, add(m, x))) | | mins#(x, y, z) | → | null#(x) |
| if_rm#(true, n, add(m, x)) | → | rm#(n, x) | | if#(false, x, y, z) | → | head#(x) |
| if2#(true, x, y, z) | → | rm#(head(x), tail(x)) | | if2#(false, x, y, z) | → | tail#(x) |
| if2#(true, x, y, z) | → | mins#(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | rm#(n, add(m, x)) | → | if_rm#(eq(n, m), n, add(m, x)) |
| eq#(s(x), s(y)) | → | eq#(x, y) | | if2#(true, x, y, z) | → | app#(z, add(head(x), nil)) |
| if2#(true, x, y, z) | → | tail#(x) | | minsort#(x) | → | mins#(x, nil, nil) |
| if2#(true, x, y, z) | → | head#(x) | | if#(false, x, y, z) | → | min#(x) |
| rm#(n, add(m, x)) | → | eq#(n, m) | | mins#(x, y, z) | → | if#(null(x), x, y, z) |
| if2#(true, x, y, z) | → | app#(rm(head(x), tail(x)), y) | | if2#(false, x, y, z) | → | mins#(tail(x), add(head(x), y), z) |
| le#(s(x), s(y)) | → | le#(x, y) | | 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, false, if_rm, head, null, nil, eq
Strategy
The following SCCs where found
| if#(false, x, y, z) → if2#(eq(head(x), min(x)), x, y, z) | if2#(true, x, y, z) → mins#(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) |
| mins#(x, y, z) → if#(null(x), x, y, z) | if2#(false, x, y, z) → mins#(tail(x), add(head(x), y), z) |
| 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
| 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, false, if_rm, head, null, 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 3: 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, false, if_rm, head, null, 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, if_rm, false, head, null, eq, nil
Strategy
There are no SCCs!
Problem 4: 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, false, if_rm, head, null, nil, eq
Strategy
Polynomial Interpretation
- 0: 1
- add(x,y): y + 2x + 1
- app(x,y): 0
- eq(x,y): 0
- false: 0
- head(x): 0
- if(x1,x2,x3,x4): 0
- if2(x1,x2,x3,x4): 0
- if_min(x,y): 0
- if_min#(x,y): y
- if_rm(x,y,z): 0
- le(x,y): 2x
- min(x): 0
- min#(x): x
- mins(x,y,z): 0
- minsort(x): 0
- nil: 0
- null(x): 0
- rm(x,y): 0
- s(x): 1
- tail(x): 0
- 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_min#(false, add(n, add(m, x))) | → | min#(add(m, x)) | | if_min#(true, add(n, add(m, x))) | → | min#(add(n, x)) |
Problem 9: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| min#(add(n, add(m, x))) | → | if_min#(le(n, m), add(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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, if_rm, false, head, null, eq, nil
Strategy
There are no SCCs!
Problem 5: 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, false, if_rm, head, null, nil, eq
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| le#(s(x), s(y)) | → | le#(x, y) |
Problem 6: 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)) | | head(add(n, x)) | → | n |
| tail(add(n, x)) | → | x | | tail(nil) | → | nil |
| null(nil) | → | true | | null(add(n, x)) | → | false |
| 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(x) | → | mins(x, nil, nil) | | mins(x, y, z) | → | if(null(x), x, y, z) |
| if(true, x, y, z) | → | z | | if(false, x, y, z) | → | if2(eq(head(x), min(x)), x, y, z) |
| if2(true, x, y, z) | → | mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) | | if2(false, x, y, z) | → | mins(tail(x), add(head(x), y), z) |
Original Signature
Termination of terms over the following signature is verified: minsort, min, app, rm, true, if2, mins, add, tail, if_min, 0, s, le, if, false, if_rm, head, null, nil, eq
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| app#(add(n, x), y) | → | app#(x, y) |