TIMEOUT
The TRS could not be proven terminating. The proof attempt took 60001 ms.
The following DP Processors were used
Problem 1 was processed with processor DependencyGraph (24738ms).
| – Problem 2 was processed with processor SubtermCriterion (3ms).
| | – Problem 27 remains open; application of the following processors failed [].
| – Problem 3 was processed with processor SubtermCriterion (1ms).
| – Problem 4 was processed with processor SubtermCriterion (5ms).
| | – Problem 28 remains open; application of the following processors failed [].
| – Problem 5 was processed with processor SubtermCriterion (1ms).
| – Problem 6 was processed with processor DependencyGraph (5273ms).
| | – Problem 37 remains open; application of the following processors failed [].
| – Problem 7 was processed with processor SubtermCriterion (2ms).
| | – Problem 29 remains open; application of the following processors failed [].
| – Problem 8 was processed with processor DependencyGraph (4823ms).
| | – Problem 38 remains open; application of the following processors failed [].
| – Problem 9 was processed with processor SubtermCriterion (2ms).
| | – Problem 30 remains open; application of the following processors failed [].
| – Problem 10 was processed with processor DependencyGraph (5017ms).
| | – Problem 39 remains open; application of the following processors failed [].
| – Problem 11 was processed with processor DependencyGraph (5505ms).
| | – Problem 40 remains open; application of the following processors failed [].
| – Problem 12 was processed with processor SubtermCriterion (2ms).
| | – Problem 31 remains open; application of the following processors failed [].
| – Problem 13 was processed with processor SubtermCriterion (1ms).
| – Problem 14 was processed with processor SubtermCriterion (2ms).
| – Problem 15 was processed with processor DependencyGraph (5165ms).
| | – Problem 41 remains open; application of the following processors failed [].
| – Problem 16 remains open; application of the following processors failed [SubtermCriterion (1ms), DependencyGraph (timeout)].
| – Problem 17 was processed with processor DependencyGraph (5270ms).
| | – Problem 42 remains open; application of the following processors failed [].
| – Problem 18 was processed with processor SubtermCriterion (1ms).
| – Problem 19 was processed with processor SubtermCriterion (3ms).
| | – Problem 32 remains open; application of the following processors failed [DependencyGraph (5ms)].
| – Problem 20 was processed with processor SubtermCriterion (2ms).
| | – Problem 34 remains open; application of the following processors failed [DependencyGraph (6ms)].
| – Problem 21 was processed with processor SubtermCriterion (1ms).
| | – Problem 33 remains open; application of the following processors failed [DependencyGraph (6ms)].
| – Problem 22 remains open; application of the following processors failed [SubtermCriterion (1ms)].
| – Problem 23 was processed with processor SubtermCriterion (4ms).
| | – Problem 35 remains open; application of the following processors failed [DependencyGraph (6ms)].
| – Problem 24 was processed with processor SubtermCriterion (2ms).
| | – Problem 36 remains open; application of the following processors failed [DependencyGraph (7ms)].
| – Problem 25 was processed with processor SubtermCriterion (2ms).
| – Problem 26 remains open; application of the following processors failed [SubtermCriterion (2ms)].
The following open problems remain:
Open Dependency Pair Problem 2
Dependency Pairs
| U11#(X1, X2, X3, mark(X4)) | → | U11#(X1, X2, X3, X4) | | U11#(mark(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, active(X2), X3, X4) | → | U11#(X1, X2, X3, X4) | | U11#(X1, mark(X2), X3, X4) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, X2, active(X3), X4) | → | U11#(X1, X2, X3, X4) | | U11#(active(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, X2, mark(X3), X4) | → | U11#(X1, X2, X3, X4) | | U11#(X1, X2, X3, active(X4)) | → | U11#(X1, X2, X3, X4) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 4
Dependency Pairs
| and#(active(X1), X2) | → | and#(X1, X2) | | mark#(and(X1, X2)) | → | and#(mark(X1), X2) |
| and#(X1, active(X2)) | → | and#(X1, X2) | | and#(mark(X1), X2) | → | and#(X1, X2) |
| and#(X1, mark(X2)) | → | and#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 6
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) | | mark#(tt) | → | active#(tt) |
| mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(head(X)) | → | mark#(X) | | mark#(nil) | → | active#(nil) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(snd(X)) | → | mark#(X) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(natsFrom(X)) | → | natsFrom#(mark(X)) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 7
Dependency Pairs
| cons#(X1, active(X2)) | → | cons#(X1, X2) | | cons#(mark(X1), X2) | → | cons#(X1, X2) |
| cons#(X1, mark(X2)) | → | cons#(X1, X2) | | cons#(active(X1), X2) | → | cons#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 8
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| mark#(tt) | → | active#(tt) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(head(X)) | → | mark#(X) |
| mark#(nil) | → | active#(nil) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(snd(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | mark#(take(X1, X2)) | → | mark#(X2) |
| mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 9
Dependency Pairs
| and#(active(X1), X2) | → | and#(X1, X2) | | and#(X1, active(X2)) | → | and#(X1, X2) |
| and#(mark(X1), X2) | → | and#(X1, X2) | | and#(X1, mark(X2)) | → | and#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 10
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) |
| mark#(fst(X)) | → | active#(fst(mark(X))) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) | → | mark#(X) | | active#(snd(pair(X, Y))) | → | mark#(Y) |
| mark#(afterNth(X1, X2)) | → | mark#(X2) | | active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) | → | active#(head(mark(X))) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(tt) | → | active#(tt) | | mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(head(X)) | → | mark#(X) |
| mark#(nil) | → | active#(nil) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(snd(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | mark#(take(X1, X2)) | → | mark#(X2) |
| mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 11
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| mark#(tt) | → | active#(tt) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(nil) | → | active#(nil) | | mark#(head(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(snd(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) | | mark#(take(X1, X2)) | → | mark#(X2) |
| mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | natsFrom#(mark(X)) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 12
Dependency Pairs
| U12#(active(X1), X2) | → | U12#(X1, X2) | | U12#(X1, active(X2)) | → | U12#(X1, X2) |
| U12#(mark(X1), X2) | → | U12#(X1, X2) | | U12#(X1, mark(X2)) | → | U12#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 15
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) | | mark#(tt) | → | active#(tt) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(nil) | → | active#(nil) |
| mark#(head(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(snd(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 17
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) |
| mark#(fst(X)) | → | active#(fst(mark(X))) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) | → | active#(head(mark(X))) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(tt) | → | active#(tt) | | mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(nil) | → | active#(nil) |
| mark#(head(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(snd(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 16
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| mark#(afterNth(X1, X2)) | → | mark#(X2) | | active#(snd(pair(X, Y))) | → | mark#(Y) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) | | mark#(tt) | → | active#(tt) |
| mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(head(X)) | → | mark#(X) | | mark#(nil) | → | active#(nil) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(snd(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 19
Dependency Pairs
| sel#(mark(X1), X2) | → | sel#(X1, X2) | | sel#(active(X1), X2) | → | sel#(X1, X2) |
| sel#(X1, active(X2)) | → | sel#(X1, X2) | | sel#(X1, mark(X2)) | → | sel#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 21
Dependency Pairs
| afterNth#(active(X1), X2) | → | afterNth#(X1, X2) | | afterNth#(X1, mark(X2)) | → | afterNth#(X1, X2) |
| afterNth#(X1, active(X2)) | → | afterNth#(X1, X2) | | afterNth#(mark(X1), X2) | → | afterNth#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 20
Dependency Pairs
| splitAt#(X1, mark(X2)) | → | splitAt#(X1, X2) | | splitAt#(X1, active(X2)) | → | splitAt#(X1, X2) |
| splitAt#(active(X1), X2) | → | splitAt#(X1, X2) | | splitAt#(mark(X1), X2) | → | splitAt#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 23
Dependency Pairs
| pair#(mark(X1), X2) | → | pair#(X1, X2) | | pair#(X1, active(X2)) | → | pair#(X1, X2) |
| pair#(X1, mark(X2)) | → | pair#(X1, X2) | | pair#(active(X1), X2) | → | pair#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 22
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) |
| mark#(fst(X)) | → | active#(fst(mark(X))) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) | → | mark#(X) | | active#(snd(pair(X, Y))) | → | mark#(Y) |
| mark#(afterNth(X1, X2)) | → | mark#(X2) | | active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) | → | active#(head(mark(X))) | | mark#(tt) | → | active#(tt) |
| active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(nil) | → | active#(nil) | | mark#(head(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(snd(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 24
Dependency Pairs
| take#(mark(X1), X2) | → | take#(X1, X2) | | take#(X1, active(X2)) | → | take#(X1, X2) |
| take#(X1, mark(X2)) | → | take#(X1, X2) | | take#(active(X1), X2) | → | take#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Open Dependency Pair Problem 26
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| mark#(tail(X)) | → | mark#(X) | | active#(snd(pair(X, Y))) | → | mark#(Y) |
| mark#(afterNth(X1, X2)) | → | mark#(X2) | | active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) | → | active#(head(mark(X))) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(tt) | → | active#(tt) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(head(X)) | → | mark#(X) | | mark#(nil) | → | active#(nil) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(snd(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) | | mark#(take(X1, X2)) | → | mark#(X2) |
| mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, nil, cons, snd
Problem 1: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| mark#(fst(X)) | → | active#(fst(mark(X))) | | U12#(active(X1), X2) | → | U12#(X1, X2) |
| active#(take(N, XS)) | → | splitAt#(N, XS) | | mark#(pair(X1, X2)) | → | mark#(X2) |
| mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) | | U11#(X1, X2, X3, active(X4)) | → | U11#(X1, X2, X3, X4) |
| splitAt#(mark(X1), X2) | → | splitAt#(X1, X2) | | active#(afterNth(N, XS)) | → | snd#(splitAt(N, XS)) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(snd(X)) | → | active#(snd(mark(X))) |
| mark#(s(X)) | → | mark#(X) | | active#(splitAt(0, XS)) | → | pair#(nil, XS) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(U12(X1, X2)) | → | mark#(X1) |
| active#(fst(pair(X, Y))) | → | mark#(X) | | afterNth#(active(X1), X2) | → | afterNth#(X1, X2) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | pair#(X1, mark(X2)) | → | pair#(X1, X2) |
| splitAt#(X1, mark(X2)) | → | splitAt#(X1, X2) | | fst#(active(X)) | → | fst#(X) |
| mark#(afterNth(X1, X2)) | → | mark#(X1) | | and#(mark(X1), X2) | → | and#(X1, X2) |
| sel#(X1, mark(X2)) | → | sel#(X1, X2) | | active#(sel(N, XS)) | → | head#(afterNth(N, XS)) |
| mark#(and(X1, X2)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| sel#(X1, active(X2)) | → | sel#(X1, X2) | | mark#(tail(X)) | → | mark#(X) |
| head#(active(X)) | → | head#(X) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | pair#(mark(X1), X2) | → | pair#(X1, X2) |
| U12#(X1, active(X2)) | → | U12#(X1, X2) | | active#(afterNth(N, XS)) | → | splitAt#(N, XS) |
| natsFrom#(mark(X)) | → | natsFrom#(X) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(tt) | → | active#(tt) | | cons#(mark(X1), X2) | → | cons#(X1, X2) |
| active#(U12(pair(YS, ZS), X)) | → | pair#(cons(X, YS), ZS) | | mark#(tail(X)) | → | tail#(mark(X)) |
| mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) | | U11#(X1, X2, X3, mark(X4)) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, active(X2), X3, X4) | → | U11#(X1, X2, X3, X4) | | mark#(head(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | splitAt#(X1, active(X2)) | → | splitAt#(X1, X2) |
| cons#(X1, mark(X2)) | → | cons#(X1, X2) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | snd#(mark(X)) | → | snd#(X) |
| head#(mark(X)) | → | head#(X) | | pair#(X1, active(X2)) | → | pair#(X1, X2) |
| mark#(snd(X)) | → | mark#(X) | | cons#(active(X1), X2) | → | cons#(X1, X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| snd#(active(X)) | → | snd#(X) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) |
| active#(natsFrom(N)) | → | natsFrom#(s(N)) | | mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) |
| mark#(fst(X)) | → | fst#(mark(X)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(snd(X)) | → | snd#(mark(X)) | | afterNth#(X1, mark(X2)) | → | afterNth#(X1, X2) |
| active#(U11(tt, N, X, XS)) | → | splitAt#(N, XS) | | mark#(s(X)) | → | s#(mark(X)) |
| mark#(tail(X)) | → | active#(tail(mark(X))) | | active#(sel(N, XS)) | → | afterNth#(N, XS) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| U11#(X1, X2, active(X3), X4) | → | U11#(X1, X2, X3, X4) | | U11#(active(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) |
| U12#(mark(X1), X2) | → | U12#(X1, X2) | | afterNth#(mark(X1), X2) | → | afterNth#(X1, X2) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | pair#(active(X1), X2) | → | pair#(X1, X2) |
| mark#(sel(X1, X2)) | → | sel#(mark(X1), mark(X2)) | | active#(U11(tt, N, X, XS)) | → | U12#(splitAt(N, XS), X) |
| mark#(and(X1, X2)) | → | and#(mark(X1), X2) | | tail#(mark(X)) | → | tail#(X) |
| take#(X1, mark(X2)) | → | take#(X1, X2) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | sel#(active(X1), X2) | → | sel#(X1, X2) |
| cons#(X1, active(X2)) | → | cons#(X1, X2) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | sel#(mark(X1), X2) | → | sel#(X1, X2) |
| and#(active(X1), X2) | → | and#(X1, X2) | | mark#(head(X)) | → | active#(head(mark(X))) |
| U11#(mark(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) | | active#(splitAt(s(N), cons(X, XS))) | → | U11#(tt, N, X, XS) |
| take#(mark(X1), X2) | → | take#(X1, X2) | | active#(natsFrom(N)) | → | s#(N) |
| and#(X1, active(X2)) | → | and#(X1, X2) | | mark#(pair(X1, X2)) | → | pair#(mark(X1), mark(X2)) |
| splitAt#(active(X1), X2) | → | splitAt#(X1, X2) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(nil) | → | active#(nil) | | active#(U12(pair(YS, ZS), X)) | → | cons#(X, YS) |
| U11#(X1, mark(X2), X3, X4) | → | U11#(X1, X2, X3, X4) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| tail#(active(X)) | → | tail#(X) | | take#(X1, active(X2)) | → | take#(X1, X2) |
| fst#(mark(X)) | → | fst#(X) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| active#(take(N, XS)) | → | fst#(splitAt(N, XS)) | | afterNth#(X1, active(X2)) | → | afterNth#(X1, X2) |
| mark#(cons(X1, X2)) | → | cons#(mark(X1), X2) | | U12#(X1, mark(X2)) | → | U12#(X1, X2) |
| and#(X1, mark(X2)) | → | and#(X1, X2) | | natsFrom#(active(X)) | → | natsFrom#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | U11#(X1, X2, mark(X3), X4) | → | U11#(X1, X2, X3, X4) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(head(X)) | → | head#(mark(X)) |
| mark#(take(X1, X2)) | → | take#(mark(X1), mark(X2)) | | mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) |
| s#(mark(X)) | → | s#(X) | | mark#(U11(X1, X2, X3, X4)) | → | U11#(mark(X1), X2, X3, X4) |
| mark#(take(X1, X2)) | → | mark#(X2) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| s#(active(X)) | → | s#(X) | | mark#(natsFrom(X)) | → | natsFrom#(mark(X)) |
| active#(natsFrom(N)) | → | cons#(N, natsFrom(s(N))) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
| take#(active(X1), X2) | → | take#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(fst(X)) → active#(fst(mark(X))) |
| mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(pair(X1, X2)) → mark#(X1) | active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | mark#(splitAt(X1, X2)) → splitAt#(mark(X1), mark(X2)) |
| active#(head(cons(N, XS))) → mark#(N) | mark#(nil) → active#(nil) |
| mark#(head(X)) → mark#(X) | mark#(splitAt(X1, X2)) → mark#(X1) |
| mark#(sel(X1, X2)) → mark#(X2) | mark#(and(X1, X2)) → active#(and(mark(X1), X2)) |
| mark#(fst(X)) → mark#(X) | active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) |
| mark#(0) → active#(0) | mark#(s(X)) → active#(s(mark(X))) |
| mark#(snd(X)) → mark#(X) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(natsFrom(X)) → mark#(X) | active#(and(tt, X)) → mark#(X) |
| mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) | active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) |
| mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X2) |
| mark#(U11(X1, X2, X3, X4)) → mark#(X1) | mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | mark#(pair(X1, X2)) → mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → afterNth#(mark(X1), mark(X2)) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(snd(pair(X, Y))) → mark#(Y) |
| active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) | mark#(head(X)) → active#(head(mark(X))) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | mark#(tt) → active#(tt) |
| active#(head(cons(N, XS))) → mark#(N) | mark#(nil) → active#(nil) |
| mark#(head(X)) → mark#(X) | mark#(splitAt(X1, X2)) → mark#(X1) |
| mark#(sel(X1, X2)) → mark#(X2) | mark#(and(X1, X2)) → active#(and(mark(X1), X2)) |
| mark#(fst(X)) → mark#(X) | active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) |
| mark#(0) → active#(0) | mark#(s(X)) → active#(s(mark(X))) |
| mark#(splitAt(X1, X2)) → mark#(X2) | mark#(snd(X)) → mark#(X) |
| mark#(natsFrom(X)) → mark#(X) | active#(and(tt, X)) → mark#(X) |
| mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) | active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) |
| mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X2) |
| mark#(U11(X1, X2, X3, X4)) → mark#(X1) | mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| cons#(X1, active(X2)) → cons#(X1, X2) | cons#(mark(X1), X2) → cons#(X1, X2) |
| cons#(active(X1), X2) → cons#(X1, X2) | cons#(X1, mark(X2)) → cons#(X1, X2) |
| U11#(X1, X2, X3, mark(X4)) → U11#(X1, X2, X3, X4) | U11#(mark(X1), X2, X3, X4) → U11#(X1, X2, X3, X4) |
| U11#(X1, active(X2), X3, X4) → U11#(X1, X2, X3, X4) | U11#(X1, X2, active(X3), X4) → U11#(X1, X2, X3, X4) |
| U11#(X1, mark(X2), X3, X4) → U11#(X1, X2, X3, X4) | U11#(active(X1), X2, X3, X4) → U11#(X1, X2, X3, X4) |
| U11#(X1, X2, mark(X3), X4) → U11#(X1, X2, X3, X4) | U11#(X1, X2, X3, active(X4)) → U11#(X1, X2, X3, X4) |
| pair#(mark(X1), X2) → pair#(X1, X2) | pair#(X1, mark(X2)) → pair#(X1, X2) |
| pair#(X1, active(X2)) → pair#(X1, X2) | pair#(active(X1), X2) → pair#(X1, X2) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(fst(X)) → active#(fst(mark(X))) |
| mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) |
| active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) | mark#(pair(X1, X2)) → mark#(X1) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | active#(splitAt(0, XS)) → mark#(pair(nil, XS)) |
| mark#(tt) → active#(tt) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(head(X)) → mark#(X) | mark#(nil) → active#(nil) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| fst#(mark(X)) → fst#(X) | fst#(active(X)) → fst#(X) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | mark#(pair(X1, X2)) → mark#(X1) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → afterNth#(mark(X1), mark(X2)) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(snd(pair(X, Y))) → mark#(Y) |
| active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) | mark#(head(X)) → active#(head(mark(X))) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | mark#(tt) → active#(tt) |
| mark#(splitAt(X1, X2)) → splitAt#(mark(X1), mark(X2)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(head(X)) → mark#(X) | mark#(nil) → active#(nil) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) → U12#(mark(X1), X2) | active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) |
| mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X2) |
| mark#(U11(X1, X2, X3, X4)) → mark#(X1) | mark#(natsFrom(X)) → natsFrom#(mark(X)) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| natsFrom#(mark(X)) → natsFrom#(X) | natsFrom#(active(X)) → natsFrom#(X) |
| tail#(active(X)) → tail#(X) | tail#(mark(X)) → tail#(X) |
| snd#(active(X)) → snd#(X) | snd#(mark(X)) → snd#(X) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) |
| active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) | mark#(pair(X1, X2)) → mark#(X1) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → afterNth#(mark(X1), mark(X2)) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(snd(pair(X, Y))) → mark#(Y) |
| active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) | mark#(head(X)) → active#(head(mark(X))) |
| mark#(tt) → active#(tt) | active#(splitAt(0, XS)) → mark#(pair(nil, XS)) |
| active#(head(cons(N, XS))) → mark#(N) | mark#(head(X)) → mark#(X) |
| mark#(nil) → active#(nil) | mark#(splitAt(X1, X2)) → mark#(X1) |
| mark#(sel(X1, X2)) → mark#(X2) | mark#(and(X1, X2)) → active#(and(mark(X1), X2)) |
| mark#(fst(X)) → mark#(X) | active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) |
| mark#(0) → active#(0) | mark#(s(X)) → active#(s(mark(X))) |
| mark#(splitAt(X1, X2)) → mark#(X2) | mark#(snd(X)) → mark#(X) |
| mark#(natsFrom(X)) → mark#(X) | active#(and(tt, X)) → mark#(X) |
| mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) | mark#(U12(X1, X2)) → U12#(mark(X1), X2) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| head#(mark(X)) → head#(X) | head#(active(X)) → head#(X) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | mark#(pair(X1, X2)) → mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) → U12#(mark(X1), X2) | active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) |
| mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X2) |
| mark#(U11(X1, X2, X3, X4)) → mark#(X1) | mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| U12#(X1, active(X2)) → U12#(X1, X2) | U12#(active(X1), X2) → U12#(X1, X2) |
| U12#(mark(X1), X2) → U12#(X1, X2) | U12#(X1, mark(X2)) → U12#(X1, X2) |
| and#(active(X1), X2) → and#(X1, X2) | and#(X1, active(X2)) → and#(X1, X2) |
| mark#(and(X1, X2)) → and#(mark(X1), X2) | and#(mark(X1), X2) → and#(X1, X2) |
| and#(X1, mark(X2)) → and#(X1, X2) |
| sel#(active(X1), X2) → sel#(X1, X2) | sel#(mark(X1), X2) → sel#(X1, X2) |
| sel#(X1, active(X2)) → sel#(X1, X2) | sel#(X1, mark(X2)) → sel#(X1, X2) |
| and#(active(X1), X2) → and#(X1, X2) | and#(X1, active(X2)) → and#(X1, X2) |
| and#(mark(X1), X2) → and#(X1, X2) | and#(X1, mark(X2)) → and#(X1, X2) |
| afterNth#(active(X1), X2) → afterNth#(X1, X2) | afterNth#(X1, mark(X2)) → afterNth#(X1, X2) |
| afterNth#(X1, active(X2)) → afterNth#(X1, X2) | afterNth#(mark(X1), X2) → afterNth#(X1, X2) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(sel(X1, X2)) → mark#(X1) | mark#(natsFrom(X)) → active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) | mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(pair(X1, X2)) → mark#(X1) | active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) → mark#(Y) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) | mark#(head(X)) → active#(head(mark(X))) |
| mark#(tt) → active#(tt) | active#(splitAt(0, XS)) → mark#(pair(nil, XS)) |
| mark#(splitAt(X1, X2)) → splitAt#(mark(X1), mark(X2)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(fst(X)) → active#(fst(mark(X))) |
| mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) | mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) |
| mark#(pair(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | active#(snd(pair(X, Y))) → mark#(Y) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | mark#(splitAt(X1, X2)) → splitAt#(mark(X1), mark(X2)) |
| active#(head(cons(N, XS))) → mark#(N) | mark#(head(X)) → mark#(X) |
| mark#(nil) → active#(nil) | mark#(splitAt(X1, X2)) → mark#(X1) |
| mark#(sel(X1, X2)) → mark#(X2) | mark#(and(X1, X2)) → active#(and(mark(X1), X2)) |
| mark#(fst(X)) → mark#(X) | active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) |
| mark#(0) → active#(0) | mark#(s(X)) → active#(s(mark(X))) |
| mark#(splitAt(X1, X2)) → mark#(X2) | mark#(snd(X)) → mark#(X) |
| mark#(natsFrom(X)) → mark#(X) | active#(and(tt, X)) → mark#(X) |
| mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) | mark#(U12(X1, X2)) → U12#(mark(X1), X2) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(pair(X1, X2)) → mark#(X1) | active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → afterNth#(mark(X1), mark(X2)) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(snd(pair(X, Y))) → mark#(Y) |
| active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) | mark#(head(X)) → active#(head(mark(X))) |
| mark#(tt) → active#(tt) | active#(splitAt(0, XS)) → mark#(pair(nil, XS)) |
| mark#(splitAt(X1, X2)) → splitAt#(mark(X1), mark(X2)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(snd(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X2) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(natsFrom(X)) → natsFrom#(mark(X)) | mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
| s#(mark(X)) → s#(X) | s#(active(X)) → s#(X) |
| take#(mark(X1), X2) → take#(X1, X2) | take#(X1, active(X2)) → take#(X1, X2) |
| take#(X1, mark(X2)) → take#(X1, X2) | take#(active(X1), X2) → take#(X1, X2) |
| splitAt#(X1, mark(X2)) → splitAt#(X1, X2) | splitAt#(X1, active(X2)) → splitAt#(X1, X2) |
| splitAt#(active(X1), X2) → splitAt#(X1, X2) | splitAt#(mark(X1), X2) → splitAt#(X1, X2) |
Problem 2: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| U11#(X1, X2, X3, mark(X4)) | → | U11#(X1, X2, X3, X4) | | U11#(mark(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, active(X2), X3, X4) | → | U11#(X1, X2, X3, X4) | | U11#(X1, X2, active(X3), X4) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, mark(X2), X3, X4) | → | U11#(X1, X2, X3, X4) | | U11#(active(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) |
| U11#(X1, X2, mark(X3), X4) | → | U11#(X1, X2, X3, X4) | | U11#(X1, X2, X3, active(X4)) | → | U11#(X1, X2, X3, X4) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| U11#(mark(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) | | U11#(active(X1), X2, X3, X4) | → | U11#(X1, X2, X3, X4) |
Problem 3: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| natsFrom#(mark(X)) | → | natsFrom#(X) | | natsFrom#(active(X)) | → | natsFrom#(X) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| natsFrom#(mark(X)) | → | natsFrom#(X) | | natsFrom#(active(X)) | → | natsFrom#(X) |
Problem 4: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| and#(active(X1), X2) | → | and#(X1, X2) | | and#(X1, active(X2)) | → | and#(X1, X2) |
| mark#(and(X1, X2)) | → | and#(mark(X1), X2) | | and#(mark(X1), X2) | → | and#(X1, X2) |
| and#(X1, mark(X2)) | → | and#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| and#(X1, active(X2)) | → | and#(X1, X2) | | mark#(and(X1, X2)) | → | and#(mark(X1), X2) |
| and#(X1, mark(X2)) | → | and#(X1, X2) |
Problem 5: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| fst#(mark(X)) | → | fst#(X) | | fst#(active(X)) | → | fst#(X) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| fst#(mark(X)) | → | fst#(X) | | fst#(active(X)) | → | fst#(X) |
Problem 6: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) | | mark#(tt) | → | active#(tt) |
| mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(head(X)) | → | mark#(X) | | mark#(nil) | → | active#(nil) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(snd(X)) | → | mark#(X) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(natsFrom(X)) | → | natsFrom#(mark(X)) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | mark#(pair(X1, X2)) → mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
Problem 7: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| cons#(X1, active(X2)) | → | cons#(X1, X2) | | cons#(mark(X1), X2) | → | cons#(X1, X2) |
| cons#(active(X1), X2) | → | cons#(X1, X2) | | cons#(X1, mark(X2)) | → | cons#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| cons#(mark(X1), X2) | → | cons#(X1, X2) | | cons#(active(X1), X2) | → | cons#(X1, X2) |
Problem 8: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| mark#(tt) | → | active#(tt) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(head(X)) | → | mark#(X) |
| mark#(nil) | → | active#(nil) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(snd(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(fst(X)) → active#(fst(mark(X))) |
| mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | mark#(pair(X1, X2)) → mark#(X1) |
| mark#(tail(X)) → mark#(X) | active#(snd(pair(X, Y))) → mark#(Y) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(head(X)) → mark#(X) | mark#(nil) → active#(nil) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) | active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
Problem 9: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| and#(active(X1), X2) | → | and#(X1, X2) | | and#(X1, active(X2)) | → | and#(X1, X2) |
| and#(mark(X1), X2) | → | and#(X1, X2) | | and#(X1, mark(X2)) | → | and#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| and#(active(X1), X2) | → | and#(X1, X2) | | and#(mark(X1), X2) | → | and#(X1, X2) |
Problem 10: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) |
| mark#(fst(X)) | → | active#(fst(mark(X))) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(tail(X)) | → | mark#(X) | | active#(snd(pair(X, Y))) | → | mark#(Y) |
| mark#(afterNth(X1, X2)) | → | mark#(X2) | | active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) | → | active#(head(mark(X))) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(tt) | → | active#(tt) | | mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(head(X)) | → | mark#(X) |
| mark#(nil) | → | active#(nil) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(snd(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(fst(X)) → active#(fst(mark(X))) |
| mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | mark#(pair(X1, X2)) → mark#(X1) |
| mark#(tail(X)) → mark#(X) | active#(snd(pair(X, Y))) → mark#(Y) |
| mark#(afterNth(X1, X2)) → mark#(X2) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(head(X)) → mark#(X) | mark#(nil) → active#(nil) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) | active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
Problem 11: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| mark#(tt) | → | active#(tt) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) | | active#(head(cons(N, XS))) | → | mark#(N) |
| mark#(nil) | → | active#(nil) | | mark#(head(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X1) | | mark#(sel(X1, X2)) | → | mark#(X2) |
| mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) | | mark#(fst(X)) | → | mark#(X) |
| active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) | | mark#(0) | → | active#(0) |
| mark#(s(X)) | → | active#(s(mark(X))) | | mark#(snd(X)) | → | mark#(X) |
| mark#(splitAt(X1, X2)) | → | mark#(X2) | | mark#(natsFrom(X)) | → | mark#(X) |
| active#(and(tt, X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) |
| mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) | | active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) |
| mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X2) |
| mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | natsFrom#(mark(X)) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | mark#(pair(X1, X2)) → mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
Problem 12: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| U12#(X1, active(X2)) | → | U12#(X1, X2) | | U12#(active(X1), X2) | → | U12#(X1, X2) |
| U12#(mark(X1), X2) | → | U12#(X1, X2) | | U12#(X1, mark(X2)) | → | U12#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| U12#(active(X1), X2) | → | U12#(X1, X2) | | U12#(mark(X1), X2) | → | U12#(X1, X2) |
Problem 13: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| snd#(active(X)) | → | snd#(X) | | snd#(mark(X)) | → | snd#(X) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| snd#(active(X)) | → | snd#(X) | | snd#(mark(X)) | → | snd#(X) |
Problem 14: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| head#(mark(X)) | → | head#(X) | | head#(active(X)) | → | head#(X) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| head#(mark(X)) | → | head#(X) | | head#(active(X)) | → | head#(X) |
Problem 15: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(fst(X)) | → | active#(fst(mark(X))) |
| mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(sel(X1, X2)) | → | mark#(X1) | | mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) | | mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) | | mark#(pair(X1, X2)) | → | mark#(X1) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | afterNth#(mark(X1), mark(X2)) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) | | mark#(head(X)) | → | active#(head(mark(X))) |
| active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) | | mark#(tt) | → | active#(tt) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(nil) | → | active#(nil) |
| mark#(head(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(snd(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | mark#(pair(X1, X2)) → mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
Problem 17: DependencyGraph
Dependency Pair Problem
Dependency Pairs
| active#(U12(pair(YS, ZS), X)) | → | mark#(pair(cons(X, YS), ZS)) | | mark#(cons(X1, X2)) | → | active#(cons(mark(X1), X2)) |
| mark#(fst(X)) | → | active#(fst(mark(X))) | | mark#(take(X1, X2)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | mark#(X2) | | mark#(take(X1, X2)) | → | active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) | → | active#(U11(mark(X1), X2, X3, X4)) | | mark#(tail(X)) | → | active#(tail(mark(X))) |
| active#(natsFrom(N)) | → | mark#(cons(N, natsFrom(s(N)))) | | active#(tail(cons(N, XS))) | → | mark#(XS) |
| mark#(snd(X)) | → | active#(snd(mark(X))) | | mark#(s(X)) | → | mark#(X) |
| mark#(natsFrom(X)) | → | active#(natsFrom(mark(X))) | | mark#(sel(X1, X2)) | → | mark#(X1) |
| mark#(U12(X1, X2)) | → | mark#(X1) | | active#(fst(pair(X, Y))) | → | mark#(X) |
| mark#(cons(X1, X2)) | → | mark#(X1) | | mark#(afterNth(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | active#(sel(mark(X1), mark(X2))) | | mark#(splitAt(X1, X2)) | → | active#(splitAt(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) | → | mark#(X1) | | active#(splitAt(s(N), cons(X, XS))) | → | mark#(U11(tt, N, X, XS)) |
| mark#(pair(X1, X2)) | → | mark#(X1) | | active#(U11(tt, N, X, XS)) | → | mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) | → | mark#(X) | | mark#(afterNth(X1, X2)) | → | mark#(X2) |
| active#(snd(pair(X, Y))) | → | mark#(Y) | | active#(take(N, XS)) | → | mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) | → | active#(head(mark(X))) | | active#(splitAt(0, XS)) | → | mark#(pair(nil, XS)) |
| mark#(tt) | → | active#(tt) | | mark#(splitAt(X1, X2)) | → | splitAt#(mark(X1), mark(X2)) |
| active#(head(cons(N, XS))) | → | mark#(N) | | mark#(nil) | → | active#(nil) |
| mark#(head(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X1) |
| mark#(sel(X1, X2)) | → | mark#(X2) | | mark#(and(X1, X2)) | → | active#(and(mark(X1), X2)) |
| mark#(fst(X)) | → | mark#(X) | | active#(afterNth(N, XS)) | → | mark#(snd(splitAt(N, XS))) |
| mark#(0) | → | active#(0) | | mark#(s(X)) | → | active#(s(mark(X))) |
| mark#(snd(X)) | → | mark#(X) | | mark#(splitAt(X1, X2)) | → | mark#(X2) |
| mark#(natsFrom(X)) | → | mark#(X) | | active#(and(tt, X)) | → | mark#(X) |
| mark#(afterNth(X1, X2)) | → | active#(afterNth(mark(X1), mark(X2))) | | mark#(U12(X1, X2)) | → | U12#(mark(X1), X2) |
| active#(sel(N, XS)) | → | mark#(head(afterNth(N, XS))) | | mark#(U12(X1, X2)) | → | active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) | → | mark#(X2) | | mark#(U11(X1, X2, X3, X4)) | → | mark#(X1) |
| mark#(pair(X1, X2)) | → | active#(pair(mark(X1), mark(X2))) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
The following SCCs where found
| active#(U12(pair(YS, ZS), X)) → mark#(pair(cons(X, YS), ZS)) | mark#(cons(X1, X2)) → active#(cons(mark(X1), X2)) |
| mark#(fst(X)) → active#(fst(mark(X))) | mark#(take(X1, X2)) → mark#(X1) |
| mark#(pair(X1, X2)) → mark#(X2) | mark#(take(X1, X2)) → active#(take(mark(X1), mark(X2))) |
| mark#(U11(X1, X2, X3, X4)) → active#(U11(mark(X1), X2, X3, X4)) | mark#(tail(X)) → active#(tail(mark(X))) |
| active#(natsFrom(N)) → mark#(cons(N, natsFrom(s(N)))) | active#(tail(cons(N, XS))) → mark#(XS) |
| mark#(snd(X)) → active#(snd(mark(X))) | mark#(s(X)) → mark#(X) |
| mark#(natsFrom(X)) → active#(natsFrom(mark(X))) | mark#(sel(X1, X2)) → mark#(X1) |
| mark#(U12(X1, X2)) → mark#(X1) | active#(fst(pair(X, Y))) → mark#(X) |
| mark#(cons(X1, X2)) → mark#(X1) | mark#(afterNth(X1, X2)) → mark#(X1) |
| mark#(splitAt(X1, X2)) → active#(splitAt(mark(X1), mark(X2))) | mark#(sel(X1, X2)) → active#(sel(mark(X1), mark(X2))) |
| mark#(and(X1, X2)) → mark#(X1) | mark#(pair(X1, X2)) → mark#(X1) |
| active#(splitAt(s(N), cons(X, XS))) → mark#(U11(tt, N, X, XS)) | active#(U11(tt, N, X, XS)) → mark#(U12(splitAt(N, XS), X)) |
| mark#(tail(X)) → mark#(X) | mark#(afterNth(X1, X2)) → mark#(X2) |
| active#(snd(pair(X, Y))) → mark#(Y) | active#(take(N, XS)) → mark#(fst(splitAt(N, XS))) |
| mark#(head(X)) → active#(head(mark(X))) | mark#(tt) → active#(tt) |
| active#(splitAt(0, XS)) → mark#(pair(nil, XS)) | active#(head(cons(N, XS))) → mark#(N) |
| mark#(nil) → active#(nil) | mark#(head(X)) → mark#(X) |
| mark#(splitAt(X1, X2)) → mark#(X1) | mark#(sel(X1, X2)) → mark#(X2) |
| mark#(and(X1, X2)) → active#(and(mark(X1), X2)) | mark#(fst(X)) → mark#(X) |
| active#(afterNth(N, XS)) → mark#(snd(splitAt(N, XS))) | mark#(0) → active#(0) |
| mark#(s(X)) → active#(s(mark(X))) | mark#(splitAt(X1, X2)) → mark#(X2) |
| mark#(snd(X)) → mark#(X) | mark#(natsFrom(X)) → mark#(X) |
| active#(and(tt, X)) → mark#(X) | mark#(afterNth(X1, X2)) → active#(afterNth(mark(X1), mark(X2))) |
| active#(sel(N, XS)) → mark#(head(afterNth(N, XS))) | mark#(U12(X1, X2)) → active#(U12(mark(X1), X2)) |
| mark#(take(X1, X2)) → mark#(X2) | mark#(U11(X1, X2, X3, X4)) → mark#(X1) |
| mark#(pair(X1, X2)) → active#(pair(mark(X1), mark(X2))) |
Problem 18: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| s#(mark(X)) | → | s#(X) | | s#(active(X)) | → | s#(X) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| s#(mark(X)) | → | s#(X) | | s#(active(X)) | → | s#(X) |
Problem 19: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| sel#(active(X1), X2) | → | sel#(X1, X2) | | sel#(mark(X1), X2) | → | sel#(X1, X2) |
| sel#(X1, active(X2)) | → | sel#(X1, X2) | | sel#(X1, mark(X2)) | → | sel#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| sel#(mark(X1), X2) | → | sel#(X1, X2) | | sel#(active(X1), X2) | → | sel#(X1, X2) |
Problem 20: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| splitAt#(X1, mark(X2)) | → | splitAt#(X1, X2) | | splitAt#(X1, active(X2)) | → | splitAt#(X1, X2) |
| splitAt#(active(X1), X2) | → | splitAt#(X1, X2) | | splitAt#(mark(X1), X2) | → | splitAt#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| splitAt#(active(X1), X2) | → | splitAt#(X1, X2) | | splitAt#(mark(X1), X2) | → | splitAt#(X1, X2) |
Problem 21: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| afterNth#(active(X1), X2) | → | afterNth#(X1, X2) | | afterNth#(X1, mark(X2)) | → | afterNth#(X1, X2) |
| afterNth#(X1, active(X2)) | → | afterNth#(X1, X2) | | afterNth#(mark(X1), X2) | → | afterNth#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| afterNth#(active(X1), X2) | → | afterNth#(X1, X2) | | afterNth#(mark(X1), X2) | → | afterNth#(X1, X2) |
Problem 23: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| pair#(mark(X1), X2) | → | pair#(X1, X2) | | pair#(X1, mark(X2)) | → | pair#(X1, X2) |
| pair#(X1, active(X2)) | → | pair#(X1, X2) | | pair#(active(X1), X2) | → | pair#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| pair#(mark(X1), X2) | → | pair#(X1, X2) | | pair#(active(X1), X2) | → | pair#(X1, X2) |
Problem 24: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| take#(mark(X1), X2) | → | take#(X1, X2) | | take#(X1, active(X2)) | → | take#(X1, X2) |
| take#(X1, mark(X2)) | → | take#(X1, X2) | | take#(active(X1), X2) | → | take#(X1, X2) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| take#(mark(X1), X2) | → | take#(X1, X2) | | take#(active(X1), X2) | → | take#(X1, X2) |
Problem 25: SubtermCriterion
Dependency Pair Problem
Dependency Pairs
| tail#(active(X)) | → | tail#(X) | | tail#(mark(X)) | → | tail#(X) |
Rewrite Rules
| active(U11(tt, N, X, XS)) | → | mark(U12(splitAt(N, XS), X)) | | active(U12(pair(YS, ZS), X)) | → | mark(pair(cons(X, YS), ZS)) |
| active(afterNth(N, XS)) | → | mark(snd(splitAt(N, XS))) | | active(and(tt, X)) | → | mark(X) |
| active(fst(pair(X, Y))) | → | mark(X) | | active(head(cons(N, XS))) | → | mark(N) |
| active(natsFrom(N)) | → | mark(cons(N, natsFrom(s(N)))) | | active(sel(N, XS)) | → | mark(head(afterNth(N, XS))) |
| active(snd(pair(X, Y))) | → | mark(Y) | | active(splitAt(0, XS)) | → | mark(pair(nil, XS)) |
| active(splitAt(s(N), cons(X, XS))) | → | mark(U11(tt, N, X, XS)) | | active(tail(cons(N, XS))) | → | mark(XS) |
| active(take(N, XS)) | → | mark(fst(splitAt(N, XS))) | | mark(U11(X1, X2, X3, X4)) | → | active(U11(mark(X1), X2, X3, X4)) |
| mark(tt) | → | active(tt) | | mark(U12(X1, X2)) | → | active(U12(mark(X1), X2)) |
| mark(splitAt(X1, X2)) | → | active(splitAt(mark(X1), mark(X2))) | | mark(pair(X1, X2)) | → | active(pair(mark(X1), mark(X2))) |
| mark(cons(X1, X2)) | → | active(cons(mark(X1), X2)) | | mark(afterNth(X1, X2)) | → | active(afterNth(mark(X1), mark(X2))) |
| mark(snd(X)) | → | active(snd(mark(X))) | | mark(and(X1, X2)) | → | active(and(mark(X1), X2)) |
| mark(fst(X)) | → | active(fst(mark(X))) | | mark(head(X)) | → | active(head(mark(X))) |
| mark(natsFrom(X)) | → | active(natsFrom(mark(X))) | | mark(s(X)) | → | active(s(mark(X))) |
| mark(sel(X1, X2)) | → | active(sel(mark(X1), mark(X2))) | | mark(0) | → | active(0) |
| mark(nil) | → | active(nil) | | mark(tail(X)) | → | active(tail(mark(X))) |
| mark(take(X1, X2)) | → | active(take(mark(X1), mark(X2))) | | U11(mark(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, mark(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, mark(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, mark(X4)) | → | U11(X1, X2, X3, X4) | | U11(active(X1), X2, X3, X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, active(X2), X3, X4) | → | U11(X1, X2, X3, X4) | | U11(X1, X2, active(X3), X4) | → | U11(X1, X2, X3, X4) |
| U11(X1, X2, X3, active(X4)) | → | U11(X1, X2, X3, X4) | | U12(mark(X1), X2) | → | U12(X1, X2) |
| U12(X1, mark(X2)) | → | U12(X1, X2) | | U12(active(X1), X2) | → | U12(X1, X2) |
| U12(X1, active(X2)) | → | U12(X1, X2) | | splitAt(mark(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, mark(X2)) | → | splitAt(X1, X2) | | splitAt(active(X1), X2) | → | splitAt(X1, X2) |
| splitAt(X1, active(X2)) | → | splitAt(X1, X2) | | pair(mark(X1), X2) | → | pair(X1, X2) |
| pair(X1, mark(X2)) | → | pair(X1, X2) | | pair(active(X1), X2) | → | pair(X1, X2) |
| pair(X1, active(X2)) | → | pair(X1, X2) | | cons(mark(X1), X2) | → | cons(X1, X2) |
| cons(X1, mark(X2)) | → | cons(X1, X2) | | cons(active(X1), X2) | → | cons(X1, X2) |
| cons(X1, active(X2)) | → | cons(X1, X2) | | afterNth(mark(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, mark(X2)) | → | afterNth(X1, X2) | | afterNth(active(X1), X2) | → | afterNth(X1, X2) |
| afterNth(X1, active(X2)) | → | afterNth(X1, X2) | | snd(mark(X)) | → | snd(X) |
| snd(active(X)) | → | snd(X) | | and(mark(X1), X2) | → | and(X1, X2) |
| and(X1, mark(X2)) | → | and(X1, X2) | | and(active(X1), X2) | → | and(X1, X2) |
| and(X1, active(X2)) | → | and(X1, X2) | | fst(mark(X)) | → | fst(X) |
| fst(active(X)) | → | fst(X) | | head(mark(X)) | → | head(X) |
| head(active(X)) | → | head(X) | | natsFrom(mark(X)) | → | natsFrom(X) |
| natsFrom(active(X)) | → | natsFrom(X) | | s(mark(X)) | → | s(X) |
| s(active(X)) | → | s(X) | | sel(mark(X1), X2) | → | sel(X1, X2) |
| sel(X1, mark(X2)) | → | sel(X1, X2) | | sel(active(X1), X2) | → | sel(X1, X2) |
| sel(X1, active(X2)) | → | sel(X1, X2) | | tail(mark(X)) | → | tail(X) |
| tail(active(X)) | → | tail(X) | | take(mark(X1), X2) | → | take(X1, X2) |
| take(X1, mark(X2)) | → | take(X1, X2) | | take(active(X1), X2) | → | take(X1, X2) |
| take(X1, active(X2)) | → | take(X1, X2) |
Original Signature
Termination of terms over the following signature is verified: pair, natsFrom, mark, tail, splitAt, and, fst, 0, s, tt, take, active, U11, U12, afterNth, head, sel, snd, cons, nil
Strategy
Projection
The following projection was used:
Thus, the following dependency pairs are removed:
| tail#(active(X)) | → | tail#(X) | | tail#(mark(X)) | → | tail#(X) |