Termination w.r.t. Q of the given QTRS could not be shown:

(0) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.

(2) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(U101(tt, N, XS)) → FST(splitAt(N, XS))
ACTIVE(U101(tt, N, XS)) → SPLITAT(N, XS)
ACTIVE(U11(tt, N, XS)) → SND(splitAt(N, XS))
ACTIVE(U11(tt, N, XS)) → SPLITAT(N, XS)
ACTIVE(U41(tt, N)) → CONS(N, natsFrom(s(N)))
ACTIVE(U41(tt, N)) → NATSFROM(s(N))
ACTIVE(U41(tt, N)) → S(N)
ACTIVE(U51(tt, N, XS)) → HEAD(afterNth(N, XS))
ACTIVE(U51(tt, N, XS)) → AFTERNTH(N, XS)
ACTIVE(U71(tt, XS)) → PAIR(nil, XS)
ACTIVE(U81(tt, N, X, XS)) → U82¹(splitAt(N, XS), X)
ACTIVE(U81(tt, N, X, XS)) → SPLITAT(N, XS)
ACTIVE(U82(pair(YS, ZS), X)) → PAIR(cons(X, YS), ZS)
ACTIVE(U82(pair(YS, ZS), X)) → CONS(X, YS)
ACTIVE(afterNth(N, XS)) → U11¹(and(isNatural(N), isLNat(XS)), N, XS)
ACTIVE(afterNth(N, XS)) → AND(isNatural(N), isLNat(XS))
ACTIVE(afterNth(N, XS)) → ISNATURAL(N)
ACTIVE(afterNth(N, XS)) → ISLNAT(XS)
ACTIVE(fst(pair(X, Y))) → U21¹(and(isLNat(X), isLNat(Y)), X)
ACTIVE(fst(pair(X, Y))) → AND(isLNat(X), isLNat(Y))
ACTIVE(fst(pair(X, Y))) → ISLNAT(X)
ACTIVE(fst(pair(X, Y))) → ISLNAT(Y)
ACTIVE(head(cons(N, XS))) → U31¹(and(isNatural(N), isLNat(XS)), N)
ACTIVE(head(cons(N, XS))) → AND(isNatural(N), isLNat(XS))
ACTIVE(head(cons(N, XS))) → ISNATURAL(N)
ACTIVE(head(cons(N, XS))) → ISLNAT(XS)
ACTIVE(isLNat(afterNth(V1, V2))) → AND(isNatural(V1), isLNat(V2))
ACTIVE(isLNat(afterNth(V1, V2))) → ISNATURAL(V1)
ACTIVE(isLNat(afterNth(V1, V2))) → ISLNAT(V2)
ACTIVE(isLNat(cons(V1, V2))) → AND(isNatural(V1), isLNat(V2))
ACTIVE(isLNat(cons(V1, V2))) → ISNATURAL(V1)
ACTIVE(isLNat(cons(V1, V2))) → ISLNAT(V2)
ACTIVE(isLNat(fst(V1))) → ISPLNAT(V1)
ACTIVE(isLNat(natsFrom(V1))) → ISNATURAL(V1)
ACTIVE(isLNat(snd(V1))) → ISPLNAT(V1)
ACTIVE(isLNat(tail(V1))) → ISLNAT(V1)
ACTIVE(isLNat(take(V1, V2))) → AND(isNatural(V1), isLNat(V2))
ACTIVE(isLNat(take(V1, V2))) → ISNATURAL(V1)
ACTIVE(isLNat(take(V1, V2))) → ISLNAT(V2)
ACTIVE(isNatural(head(V1))) → ISLNAT(V1)
ACTIVE(isNatural(s(V1))) → ISNATURAL(V1)
ACTIVE(isNatural(sel(V1, V2))) → AND(isNatural(V1), isLNat(V2))
ACTIVE(isNatural(sel(V1, V2))) → ISNATURAL(V1)
ACTIVE(isNatural(sel(V1, V2))) → ISLNAT(V2)
ACTIVE(isPLNat(pair(V1, V2))) → AND(isLNat(V1), isLNat(V2))
ACTIVE(isPLNat(pair(V1, V2))) → ISLNAT(V1)
ACTIVE(isPLNat(pair(V1, V2))) → ISLNAT(V2)
ACTIVE(isPLNat(splitAt(V1, V2))) → AND(isNatural(V1), isLNat(V2))
ACTIVE(isPLNat(splitAt(V1, V2))) → ISNATURAL(V1)
ACTIVE(isPLNat(splitAt(V1, V2))) → ISLNAT(V2)
ACTIVE(natsFrom(N)) → U41¹(isNatural(N), N)
ACTIVE(natsFrom(N)) → ISNATURAL(N)
ACTIVE(sel(N, XS)) → U51¹(and(isNatural(N), isLNat(XS)), N, XS)
ACTIVE(sel(N, XS)) → AND(isNatural(N), isLNat(XS))
ACTIVE(sel(N, XS)) → ISNATURAL(N)
ACTIVE(sel(N, XS)) → ISLNAT(XS)
ACTIVE(snd(pair(X, Y))) → U61¹(and(isLNat(X), isLNat(Y)), Y)
ACTIVE(snd(pair(X, Y))) → AND(isLNat(X), isLNat(Y))
ACTIVE(snd(pair(X, Y))) → ISLNAT(X)
ACTIVE(snd(pair(X, Y))) → ISLNAT(Y)
ACTIVE(splitAt(0, XS)) → U71¹(isLNat(XS), XS)
ACTIVE(splitAt(0, XS)) → ISLNAT(XS)
ACTIVE(splitAt(s(N), cons(X, XS))) → U81¹(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ACTIVE(splitAt(s(N), cons(X, XS))) → AND(isNatural(N), and(isNatural(X), isLNat(XS)))
ACTIVE(splitAt(s(N), cons(X, XS))) → ISNATURAL(N)
ACTIVE(splitAt(s(N), cons(X, XS))) → AND(isNatural(X), isLNat(XS))
ACTIVE(splitAt(s(N), cons(X, XS))) → ISNATURAL(X)
ACTIVE(splitAt(s(N), cons(X, XS))) → ISLNAT(XS)
ACTIVE(tail(cons(N, XS))) → U91¹(and(isNatural(N), isLNat(XS)), XS)
ACTIVE(tail(cons(N, XS))) → AND(isNatural(N), isLNat(XS))
ACTIVE(tail(cons(N, XS))) → ISNATURAL(N)
ACTIVE(tail(cons(N, XS))) → ISLNAT(XS)
ACTIVE(take(N, XS)) → U101¹(and(isNatural(N), isLNat(XS)), N, XS)
ACTIVE(take(N, XS)) → AND(isNatural(N), isLNat(XS))
ACTIVE(take(N, XS)) → ISNATURAL(N)
ACTIVE(take(N, XS)) → ISLNAT(XS)
ACTIVE(U101(X1, X2, X3)) → U101¹(active(X1), X2, X3)
ACTIVE(U101(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(fst(X)) → FST(active(X))
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(splitAt(X1, X2)) → SPLITAT(active(X1), X2)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → SPLITAT(X1, active(X2))
ACTIVE(splitAt(X1, X2)) → ACTIVE(X2)
ACTIVE(U11(X1, X2, X3)) → U11¹(active(X1), X2, X3)
ACTIVE(U11(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(snd(X)) → SND(active(X))
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(U21(X1, X2)) → U21¹(active(X1), X2)
ACTIVE(U21(X1, X2)) → ACTIVE(X1)
ACTIVE(U31(X1, X2)) → U31¹(active(X1), X2)
ACTIVE(U31(X1, X2)) → ACTIVE(X1)
ACTIVE(U41(X1, X2)) → U41¹(active(X1), X2)
ACTIVE(U41(X1, X2)) → ACTIVE(X1)
ACTIVE(cons(X1, X2)) → CONS(active(X1), X2)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(natsFrom(X)) → NATSFROM(active(X))
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → S(active(X))
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(U51(X1, X2, X3)) → U51¹(active(X1), X2, X3)
ACTIVE(U51(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(head(X)) → HEAD(active(X))
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(afterNth(X1, X2)) → AFTERNTH(active(X1), X2)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → AFTERNTH(X1, active(X2))
ACTIVE(afterNth(X1, X2)) → ACTIVE(X2)
ACTIVE(U61(X1, X2)) → U61¹(active(X1), X2)
ACTIVE(U61(X1, X2)) → ACTIVE(X1)
ACTIVE(U71(X1, X2)) → U71¹(active(X1), X2)
ACTIVE(U71(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → PAIR(active(X1), X2)
ACTIVE(pair(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → PAIR(X1, active(X2))
ACTIVE(pair(X1, X2)) → ACTIVE(X2)
ACTIVE(U81(X1, X2, X3, X4)) → U81¹(active(X1), X2, X3, X4)
ACTIVE(U81(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(U82(X1, X2)) → U82¹(active(X1), X2)
ACTIVE(U82(X1, X2)) → ACTIVE(X1)
ACTIVE(U91(X1, X2)) → U91¹(active(X1), X2)
ACTIVE(U91(X1, X2)) → ACTIVE(X1)
ACTIVE(and(X1, X2)) → AND(active(X1), X2)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(tail(X)) → TAIL(active(X))
ACTIVE(tail(X)) → ACTIVE(X)
ACTIVE(take(X1, X2)) → TAKE(active(X1), X2)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → TAKE(X1, active(X2))
ACTIVE(take(X1, X2)) → ACTIVE(X2)
ACTIVE(sel(X1, X2)) → SEL(active(X1), X2)
ACTIVE(sel(X1, X2)) → ACTIVE(X1)
ACTIVE(sel(X1, X2)) → SEL(X1, active(X2))
ACTIVE(sel(X1, X2)) → ACTIVE(X2)
U101¹(mark(X1), X2, X3) → U101¹(X1, X2, X3)
FST(mark(X)) → FST(X)
SPLITAT(mark(X1), X2) → SPLITAT(X1, X2)
SPLITAT(X1, mark(X2)) → SPLITAT(X1, X2)
U11¹(mark(X1), X2, X3) → U11¹(X1, X2, X3)
SND(mark(X)) → SND(X)
U21¹(mark(X1), X2) → U21¹(X1, X2)
U31¹(mark(X1), X2) → U31¹(X1, X2)
U41¹(mark(X1), X2) → U41¹(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)
NATSFROM(mark(X)) → NATSFROM(X)
S(mark(X)) → S(X)
U51¹(mark(X1), X2, X3) → U51¹(X1, X2, X3)
HEAD(mark(X)) → HEAD(X)
AFTERNTH(mark(X1), X2) → AFTERNTH(X1, X2)
AFTERNTH(X1, mark(X2)) → AFTERNTH(X1, X2)
U61¹(mark(X1), X2) → U61¹(X1, X2)
U71¹(mark(X1), X2) → U71¹(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)
PAIR(X1, mark(X2)) → PAIR(X1, X2)
U81¹(mark(X1), X2, X3, X4) → U81¹(X1, X2, X3, X4)
U82¹(mark(X1), X2) → U82¹(X1, X2)
U91¹(mark(X1), X2) → U91¹(X1, X2)
AND(mark(X1), X2) → AND(X1, X2)
TAIL(mark(X)) → TAIL(X)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(X1, mark(X2)) → TAKE(X1, X2)
SEL(mark(X1), X2) → SEL(X1, X2)
SEL(X1, mark(X2)) → SEL(X1, X2)
PROPER(U101(X1, X2, X3)) → U101¹(proper(X1), proper(X2), proper(X3))
PROPER(U101(X1, X2, X3)) → PROPER(X1)
PROPER(U101(X1, X2, X3)) → PROPER(X2)
PROPER(U101(X1, X2, X3)) → PROPER(X3)
PROPER(fst(X)) → FST(proper(X))
PROPER(fst(X)) → PROPER(X)
PROPER(splitAt(X1, X2)) → SPLITAT(proper(X1), proper(X2))
PROPER(splitAt(X1, X2)) → PROPER(X1)
PROPER(splitAt(X1, X2)) → PROPER(X2)
PROPER(U11(X1, X2, X3)) → U11¹(proper(X1), proper(X2), proper(X3))
PROPER(U11(X1, X2, X3)) → PROPER(X1)
PROPER(U11(X1, X2, X3)) → PROPER(X2)
PROPER(U11(X1, X2, X3)) → PROPER(X3)
PROPER(snd(X)) → SND(proper(X))
PROPER(snd(X)) → PROPER(X)
PROPER(U21(X1, X2)) → U21¹(proper(X1), proper(X2))
PROPER(U21(X1, X2)) → PROPER(X1)
PROPER(U21(X1, X2)) → PROPER(X2)
PROPER(U31(X1, X2)) → U31¹(proper(X1), proper(X2))
PROPER(U31(X1, X2)) → PROPER(X1)
PROPER(U31(X1, X2)) → PROPER(X2)
PROPER(U41(X1, X2)) → U41¹(proper(X1), proper(X2))
PROPER(U41(X1, X2)) → PROPER(X1)
PROPER(U41(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → CONS(proper(X1), proper(X2))
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(natsFrom(X)) → NATSFROM(proper(X))
PROPER(natsFrom(X)) → PROPER(X)
PROPER(s(X)) → S(proper(X))
PROPER(s(X)) → PROPER(X)
PROPER(U51(X1, X2, X3)) → U51¹(proper(X1), proper(X2), proper(X3))
PROPER(U51(X1, X2, X3)) → PROPER(X1)
PROPER(U51(X1, X2, X3)) → PROPER(X2)
PROPER(U51(X1, X2, X3)) → PROPER(X3)
PROPER(head(X)) → HEAD(proper(X))
PROPER(head(X)) → PROPER(X)
PROPER(afterNth(X1, X2)) → AFTERNTH(proper(X1), proper(X2))
PROPER(afterNth(X1, X2)) → PROPER(X1)
PROPER(afterNth(X1, X2)) → PROPER(X2)
PROPER(U61(X1, X2)) → U61¹(proper(X1), proper(X2))
PROPER(U61(X1, X2)) → PROPER(X1)
PROPER(U61(X1, X2)) → PROPER(X2)
PROPER(U71(X1, X2)) → U71¹(proper(X1), proper(X2))
PROPER(U71(X1, X2)) → PROPER(X1)
PROPER(U71(X1, X2)) → PROPER(X2)
PROPER(pair(X1, X2)) → PAIR(proper(X1), proper(X2))
PROPER(pair(X1, X2)) → PROPER(X1)
PROPER(pair(X1, X2)) → PROPER(X2)
PROPER(U81(X1, X2, X3, X4)) → U81¹(proper(X1), proper(X2), proper(X3), proper(X4))
PROPER(U81(X1, X2, X3, X4)) → PROPER(X1)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X2)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X3)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X4)
PROPER(U82(X1, X2)) → U82¹(proper(X1), proper(X2))
PROPER(U82(X1, X2)) → PROPER(X1)
PROPER(U82(X1, X2)) → PROPER(X2)
PROPER(U91(X1, X2)) → U91¹(proper(X1), proper(X2))
PROPER(U91(X1, X2)) → PROPER(X1)
PROPER(U91(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → AND(proper(X1), proper(X2))
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(isNatural(X)) → ISNATURAL(proper(X))
PROPER(isNatural(X)) → PROPER(X)
PROPER(isLNat(X)) → ISLNAT(proper(X))
PROPER(isLNat(X)) → PROPER(X)
PROPER(isPLNat(X)) → ISPLNAT(proper(X))
PROPER(isPLNat(X)) → PROPER(X)
PROPER(tail(X)) → TAIL(proper(X))
PROPER(tail(X)) → PROPER(X)
PROPER(take(X1, X2)) → TAKE(proper(X1), proper(X2))
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)
PROPER(sel(X1, X2)) → SEL(proper(X1), proper(X2))
PROPER(sel(X1, X2)) → PROPER(X1)
PROPER(sel(X1, X2)) → PROPER(X2)
U101¹(ok(X1), ok(X2), ok(X3)) → U101¹(X1, X2, X3)
FST(ok(X)) → FST(X)
SPLITAT(ok(X1), ok(X2)) → SPLITAT(X1, X2)
U11¹(ok(X1), ok(X2), ok(X3)) → U11¹(X1, X2, X3)
SND(ok(X)) → SND(X)
U21¹(ok(X1), ok(X2)) → U21¹(X1, X2)
U31¹(ok(X1), ok(X2)) → U31¹(X1, X2)
U41¹(ok(X1), ok(X2)) → U41¹(X1, X2)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
NATSFROM(ok(X)) → NATSFROM(X)
S(ok(X)) → S(X)
U51¹(ok(X1), ok(X2), ok(X3)) → U51¹(X1, X2, X3)
HEAD(ok(X)) → HEAD(X)
AFTERNTH(ok(X1), ok(X2)) → AFTERNTH(X1, X2)
U61¹(ok(X1), ok(X2)) → U61¹(X1, X2)
U71¹(ok(X1), ok(X2)) → U71¹(X1, X2)
PAIR(ok(X1), ok(X2)) → PAIR(X1, X2)
U81¹(ok(X1), ok(X2), ok(X3), ok(X4)) → U81¹(X1, X2, X3, X4)
U82¹(ok(X1), ok(X2)) → U82¹(X1, X2)
U91¹(ok(X1), ok(X2)) → U91¹(X1, X2)
AND(ok(X1), ok(X2)) → AND(X1, X2)
ISNATURAL(ok(X)) → ISNATURAL(X)
ISLNAT(ok(X)) → ISLNAT(X)
ISPLNAT(ok(X)) → ISPLNAT(X)
TAIL(ok(X)) → TAIL(X)
TAKE(ok(X1), ok(X2)) → TAKE(X1, X2)
SEL(ok(X1), ok(X2)) → SEL(X1, X2)
TOP(mark(X)) → TOP(proper(X))
TOP(mark(X)) → PROPER(X)
TOP(ok(X)) → TOP(active(X))
TOP(ok(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(3) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 30 SCCs with 134 less nodes.

(4) Complex Obligation (AND)

(5) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISPLNAT(ok(X)) → ISPLNAT(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(6) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ISPLNAT(ok(X)) → ISPLNAT(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISPLNAT(x1)  =  ISPLNAT(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

ISPLNAT₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

ISPLNAT₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(7) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(8) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(9) TRUE

(10) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISLNAT(ok(X)) → ISLNAT(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(11) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ISLNAT(ok(X)) → ISLNAT(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISLNAT(x1)  =  ISLNAT(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

ISLNAT₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

ISLNAT₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(12) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(13) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(14) TRUE

(15) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATURAL(ok(X)) → ISNATURAL(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(16) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ISNATURAL(ok(X)) → ISNATURAL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNATURAL(x1)  =  ISNATURAL(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

ISNATURAL₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

ISNATURAL₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(17) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(18) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(19) TRUE

(20) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SEL(X1, mark(X2)) → SEL(X1, X2)
SEL(mark(X1), X2) → SEL(X1, X2)
SEL(ok(X1), ok(X2)) → SEL(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(21) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SEL(ok(X1), ok(X2)) → SEL(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SEL(x1, x2)  =  SEL(x1, x2)
mark(x1)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  x3
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  x3
head(x1)  =  head(x1)
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

SEL₂ > ok₁
top > active₁ > tt > cons₂ > ok₁
top > active₁ > tt > natsFrom₁ > ok₁
top > active₁ > tt > head₁ > and₁ > ok₁
top > active₁ > tt > pair₂ > U61₂ > ok₁
top > active₁ > tt > nil > ok₁
top > active₁ > snd₁ > U61₂ > ok₁
top > active₁ > snd₁ > isPLNat₁ > and₁ > ok₁
top > active₁ > U21₂ > ok₁
top > active₁ > U31₂ > ok₁
top > active₁ > U71₂ > ok₁
top > active₁ > U81₃ > ok₁
top > active₁ > U82₂ > cons₂ > ok₁
top > active₁ > U82₂ > pair₂ > U61₂ > ok₁
top > active₁ > U91₂ > ok₁
top > active₁ > take₂ > ok₁
top > active₁ > sel₂ > ok₁
top > proper₁ > tt > cons₂ > ok₁
top > proper₁ > tt > natsFrom₁ > ok₁
top > proper₁ > tt > head₁ > and₁ > ok₁
top > proper₁ > tt > pair₂ > U61₂ > ok₁
top > proper₁ > tt > nil > ok₁
top > proper₁ > snd₁ > U61₂ > ok₁
top > proper₁ > snd₁ > isPLNat₁ > and₁ > ok₁
top > proper₁ > U21₂ > ok₁
top > proper₁ > U31₂ > ok₁
top > proper₁ > U81₃ > ok₁
top > proper₁ > U82₂ > cons₂ > ok₁
top > proper₁ > U82₂ > pair₂ > U61₂ > ok₁
top > proper₁ > U91₂ > ok₁
top > proper₁ > take₂ > ok₁
top > proper₁ > 0 > U71₂ > ok₁
top > proper₁ > sel₂ > ok₁

Status:

SEL₂: [1,2]
ok₁: [1]
active₁: [1]
tt: multiset
snd₁: multiset
U21₂: [2,1]
U31₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
head₁: multiset
U61₂: [2,1]
U71₂: multiset
pair₂: multiset
nil: multiset
U81₃: [2,1,3]
U82₂: [2,1]
U91₂: [1,2]
and₁: [1]
isPLNat₁: [1]
take₂: [2,1]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(22) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SEL(X1, mark(X2)) → SEL(X1, X2)
SEL(mark(X1), X2) → SEL(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(23) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SEL(X1, mark(X2)) → SEL(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SEL(x1, x2)  =  SEL(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural
isLNat(x1)  =  isLNat
isPLNat(x1)  =  isPLNat
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  x1
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > splitAt₂ > isNatural > mark₁ > top
active₁ > U101₃ > splitAt₂ > isNatural > ok > top
active₁ > U31₂ > mark₁ > top
active₁ > U31₂ > ok > top
active₁ > U41₂ > cons₂ > mark₁ > top
active₁ > U41₂ > cons₂ > ok > top
active₁ > s₁ > U81₄ > splitAt₂ > isNatural > mark₁ > top
active₁ > s₁ > U81₄ > splitAt₂ > isNatural > ok > top
active₁ > s₁ > U81₄ > U82₂ > cons₂ > mark₁ > top
active₁ > s₁ > U81₄ > U82₂ > cons₂ > ok > top
active₁ > s₁ > isLNat > tt > U82₂ > cons₂ > mark₁ > top
active₁ > s₁ > isLNat > tt > U82₂ > cons₂ > ok > top
active₁ > s₁ > isLNat > isNatural > mark₁ > top
active₁ > s₁ > isLNat > isNatural > ok > top
active₁ > afterNth₂ > U11₃ > snd₁ > mark₁ > top
active₁ > afterNth₂ > U11₃ > snd₁ > ok > top
active₁ > afterNth₂ > isLNat > tt > U82₂ > cons₂ > mark₁ > top
active₁ > afterNth₂ > isLNat > tt > U82₂ > cons₂ > ok > top
active₁ > afterNth₂ > isLNat > isNatural > mark₁ > top
active₁ > afterNth₂ > isLNat > isNatural > ok > top
active₁ > U71₂ > nil > tt > U82₂ > cons₂ > mark₁ > top
active₁ > U71₂ > nil > tt > U82₂ > cons₂ > ok > top
active₁ > pair₂ > U21₂ > mark₁ > top
active₁ > pair₂ > U21₂ > ok > top
active₁ > pair₂ > U61₂ > mark₁ > top
active₁ > pair₂ > U61₂ > ok > top
active₁ > pair₂ > isLNat > tt > U82₂ > cons₂ > mark₁ > top
active₁ > pair₂ > isLNat > tt > U82₂ > cons₂ > ok > top
active₁ > pair₂ > isLNat > isNatural > mark₁ > top
active₁ > pair₂ > isLNat > isNatural > ok > top
active₁ > U91₂ > mark₁ > top
active₁ > U91₂ > ok > top
active₁ > and₂ > mark₁ > top
active₁ > and₂ > ok > top
active₁ > isPLNat > isLNat > tt > U82₂ > cons₂ > mark₁ > top
active₁ > isPLNat > isLNat > tt > U82₂ > cons₂ > ok > top
active₁ > isPLNat > isLNat > isNatural > mark₁ > top
active₁ > isPLNat > isLNat > isNatural > ok > top
active₁ > tail₁ > mark₁ > top
active₁ > tail₁ > ok > top
active₁ > take₂ > isNatural > mark₁ > top
active₁ > take₂ > isNatural > ok > top
active₁ > sel₂ > U51₃ > mark₁ > top
active₁ > sel₂ > U51₃ > ok > top
active₁ > sel₂ > isLNat > tt > U82₂ > cons₂ > mark₁ > top
active₁ > sel₂ > isLNat > tt > U82₂ > cons₂ > ok > top
active₁ > sel₂ > isLNat > isNatural > mark₁ > top
active₁ > sel₂ > isLNat > isNatural > ok > top
0 > ok > top

Status:

SEL₁: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
s₁: [1]
U51₃: [1,2,3]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: multiset
U82₂: [2,1]
U91₂: [1,2]
and₂: [2,1]
isNatural: multiset
isLNat: []
isPLNat: []
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: [2,1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(24) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SEL(mark(X1), X2) → SEL(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(25) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SEL(mark(X1), X2) → SEL(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SEL(x1, x2)  =  SEL(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > ok > splitAt₂ > U81₄ > mark₁
active₁ > U101₃ > ok > U11₃ > mark₁
active₁ > U101₃ > ok > U21₂ > mark₁
active₁ > U101₃ > ok > U51₃ > afterNth₂ > mark₁
active₁ > U101₃ > ok > U61₂ > mark₁
active₁ > U101₃ > ok > U82₂ > pair₂ > mark₁
active₁ > U101₃ > ok > U91₂ > mark₁
active₁ > U101₃ > ok > isPLNat₁ > mark₁
active₁ > U101₃ > ok > take₂ > mark₁
active₁ > U31₂ > ok > splitAt₂ > U81₄ > mark₁
active₁ > U31₂ > ok > U11₃ > mark₁
active₁ > U31₂ > ok > U21₂ > mark₁
active₁ > U31₂ > ok > U51₃ > afterNth₂ > mark₁
active₁ > U31₂ > ok > U61₂ > mark₁
active₁ > U31₂ > ok > U82₂ > pair₂ > mark₁
active₁ > U31₂ > ok > U91₂ > mark₁
active₁ > U31₂ > ok > isPLNat₁ > mark₁
active₁ > U31₂ > ok > take₂ > mark₁
active₁ > U41₂ > cons₂ > U81₄ > mark₁
active₁ > U41₂ > cons₂ > U91₂ > mark₁
active₁ > U41₂ > ok > splitAt₂ > U81₄ > mark₁
active₁ > U41₂ > ok > U11₃ > mark₁
active₁ > U41₂ > ok > U21₂ > mark₁
active₁ > U41₂ > ok > U51₃ > afterNth₂ > mark₁
active₁ > U41₂ > ok > U61₂ > mark₁
active₁ > U41₂ > ok > U82₂ > pair₂ > mark₁
active₁ > U41₂ > ok > U91₂ > mark₁
active₁ > U41₂ > ok > isPLNat₁ > mark₁
active₁ > U41₂ > ok > take₂ > mark₁
active₁ > s₁ > and₂ > ok > splitAt₂ > U81₄ > mark₁
active₁ > s₁ > and₂ > ok > U11₃ > mark₁
active₁ > s₁ > and₂ > ok > U21₂ > mark₁
active₁ > s₁ > and₂ > ok > U51₃ > afterNth₂ > mark₁
active₁ > s₁ > and₂ > ok > U61₂ > mark₁
active₁ > s₁ > and₂ > ok > U82₂ > pair₂ > mark₁
active₁ > s₁ > and₂ > ok > U91₂ > mark₁
active₁ > s₁ > and₂ > ok > isPLNat₁ > mark₁
active₁ > s₁ > and₂ > ok > take₂ > mark₁
active₁ > U71₂ > nil > tt > afterNth₂ > mark₁
active₁ > U71₂ > nil > tt > pair₂ > mark₁
active₁ > U71₂ > ok > splitAt₂ > U81₄ > mark₁
active₁ > U71₂ > ok > U11₃ > mark₁
active₁ > U71₂ > ok > U21₂ > mark₁
active₁ > U71₂ > ok > U51₃ > afterNth₂ > mark₁
active₁ > U71₂ > ok > U61₂ > mark₁
active₁ > U71₂ > ok > U82₂ > pair₂ > mark₁
active₁ > U71₂ > ok > U91₂ > mark₁
active₁ > U71₂ > ok > isPLNat₁ > mark₁
active₁ > U71₂ > ok > take₂ > mark₁
active₁ > sel₂ > ok > splitAt₂ > U81₄ > mark₁
active₁ > sel₂ > ok > U11₃ > mark₁
active₁ > sel₂ > ok > U21₂ > mark₁
active₁ > sel₂ > ok > U51₃ > afterNth₂ > mark₁
active₁ > sel₂ > ok > U61₂ > mark₁
active₁ > sel₂ > ok > U82₂ > pair₂ > mark₁
active₁ > sel₂ > ok > U91₂ > mark₁
active₁ > sel₂ > ok > isPLNat₁ > mark₁
active₁ > sel₂ > ok > take₂ > mark₁
top > proper₁ > U101₃ > ok > splitAt₂ > U81₄ > mark₁
top > proper₁ > U101₃ > ok > U11₃ > mark₁
top > proper₁ > U101₃ > ok > U21₂ > mark₁
top > proper₁ > U101₃ > ok > U51₃ > afterNth₂ > mark₁
top > proper₁ > U101₃ > ok > U61₂ > mark₁
top > proper₁ > U101₃ > ok > U82₂ > pair₂ > mark₁
top > proper₁ > U101₃ > ok > U91₂ > mark₁
top > proper₁ > U101₃ > ok > isPLNat₁ > mark₁
top > proper₁ > U101₃ > ok > take₂ > mark₁
top > proper₁ > U31₂ > ok > splitAt₂ > U81₄ > mark₁
top > proper₁ > U31₂ > ok > U11₃ > mark₁
top > proper₁ > U31₂ > ok > U21₂ > mark₁
top > proper₁ > U31₂ > ok > U51₃ > afterNth₂ > mark₁
top > proper₁ > U31₂ > ok > U61₂ > mark₁
top > proper₁ > U31₂ > ok > U82₂ > pair₂ > mark₁
top > proper₁ > U31₂ > ok > U91₂ > mark₁
top > proper₁ > U31₂ > ok > isPLNat₁ > mark₁
top > proper₁ > U31₂ > ok > take₂ > mark₁
top > proper₁ > U41₂ > cons₂ > U81₄ > mark₁
top > proper₁ > U41₂ > cons₂ > U91₂ > mark₁
top > proper₁ > U41₂ > ok > splitAt₂ > U81₄ > mark₁
top > proper₁ > U41₂ > ok > U11₃ > mark₁
top > proper₁ > U41₂ > ok > U21₂ > mark₁
top > proper₁ > U41₂ > ok > U51₃ > afterNth₂ > mark₁
top > proper₁ > U41₂ > ok > U61₂ > mark₁
top > proper₁ > U41₂ > ok > U82₂ > pair₂ > mark₁
top > proper₁ > U41₂ > ok > U91₂ > mark₁
top > proper₁ > U41₂ > ok > isPLNat₁ > mark₁
top > proper₁ > U41₂ > ok > take₂ > mark₁
top > proper₁ > s₁ > and₂ > ok > splitAt₂ > U81₄ > mark₁
top > proper₁ > s₁ > and₂ > ok > U11₃ > mark₁
top > proper₁ > s₁ > and₂ > ok > U21₂ > mark₁
top > proper₁ > s₁ > and₂ > ok > U51₃ > afterNth₂ > mark₁
top > proper₁ > s₁ > and₂ > ok > U61₂ > mark₁
top > proper₁ > s₁ > and₂ > ok > U82₂ > pair₂ > mark₁
top > proper₁ > s₁ > and₂ > ok > U91₂ > mark₁
top > proper₁ > s₁ > and₂ > ok > isPLNat₁ > mark₁
top > proper₁ > s₁ > and₂ > ok > take₂ > mark₁
top > proper₁ > U71₂ > nil > tt > afterNth₂ > mark₁
top > proper₁ > U71₂ > nil > tt > pair₂ > mark₁
top > proper₁ > U71₂ > ok > splitAt₂ > U81₄ > mark₁
top > proper₁ > U71₂ > ok > U11₃ > mark₁
top > proper₁ > U71₂ > ok > U21₂ > mark₁
top > proper₁ > U71₂ > ok > U51₃ > afterNth₂ > mark₁
top > proper₁ > U71₂ > ok > U61₂ > mark₁
top > proper₁ > U71₂ > ok > U82₂ > pair₂ > mark₁
top > proper₁ > U71₂ > ok > U91₂ > mark₁
top > proper₁ > U71₂ > ok > isPLNat₁ > mark₁
top > proper₁ > U71₂ > ok > take₂ > mark₁
top > proper₁ > 0
top > proper₁ > sel₂ > ok > splitAt₂ > U81₄ > mark₁
top > proper₁ > sel₂ > ok > U11₃ > mark₁
top > proper₁ > sel₂ > ok > U21₂ > mark₁
top > proper₁ > sel₂ > ok > U51₃ > afterNth₂ > mark₁
top > proper₁ > sel₂ > ok > U61₂ > mark₁
top > proper₁ > sel₂ > ok > U82₂ > pair₂ > mark₁
top > proper₁ > sel₂ > ok > U91₂ > mark₁
top > proper₁ > sel₂ > ok > isPLNat₁ > mark₁
top > proper₁ > sel₂ > ok > take₂ > mark₁

Status:

SEL₁: [1]
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: multiset
s₁: multiset
U51₃: [1,3,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: [1,3,2,4]
U82₂: multiset
U91₂: [1,2]
and₂: [1,2]
isPLNat₁: multiset
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(26) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(27) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(28) TRUE

(29) Obligation:

Q DP problem:
The TRS P consists of the following rules:

TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(ok(X1), ok(X2)) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(30) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TAKE(ok(X1), ok(X2)) → TAKE(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAKE(x1, x2)  =  TAKE(x1, x2)
mark(x1)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

proper₁ > fst₁ > U21₁ > ok₁ > TAKE₂
proper₁ > snd₁ > isLNat₁ > ok₁ > TAKE₂
proper₁ > snd₁ > isLNat₁ > tt
proper₁ > U31₂ > ok₁ > TAKE₂
proper₁ > U51₃ > head₁ > ok₁ > TAKE₂
proper₁ > afterNth₂ > U11₃ > ok₁ > TAKE₂
proper₁ > pair₂ > U21₁ > ok₁ > TAKE₂
proper₁ > pair₂ > cons₂ > ok₁ > TAKE₂
proper₁ > pair₂ > isLNat₁ > ok₁ > TAKE₂
proper₁ > pair₂ > isLNat₁ > tt
proper₁ > nil > ok₁ > TAKE₂
proper₁ > nil > tt
proper₁ > U81₂ > ok₁ > TAKE₂
proper₁ > U82₂ > cons₂ > ok₁ > TAKE₂
proper₁ > U91₂ > ok₁ > TAKE₂
proper₁ > isPLNat₁ > isLNat₁ > ok₁ > TAKE₂
proper₁ > isPLNat₁ > isLNat₁ > tt
proper₁ > take₂ > ok₁ > TAKE₂
proper₁ > 0 > U71₂ > ok₁ > TAKE₂
proper₁ > 0 > isLNat₁ > ok₁ > TAKE₂
proper₁ > 0 > isLNat₁ > tt
proper₁ > sel₂ > ok₁ > TAKE₂
top > active₁ > fst₁ > U21₁ > ok₁ > TAKE₂
top > active₁ > snd₁ > isLNat₁ > ok₁ > TAKE₂
top > active₁ > snd₁ > isLNat₁ > tt
top > active₁ > U31₂ > ok₁ > TAKE₂
top > active₁ > U51₃ > head₁ > ok₁ > TAKE₂
top > active₁ > afterNth₂ > U11₃ > ok₁ > TAKE₂
top > active₁ > U71₂ > ok₁ > TAKE₂
top > active₁ > pair₂ > U21₁ > ok₁ > TAKE₂
top > active₁ > pair₂ > cons₂ > ok₁ > TAKE₂
top > active₁ > pair₂ > isLNat₁ > ok₁ > TAKE₂
top > active₁ > pair₂ > isLNat₁ > tt
top > active₁ > nil > ok₁ > TAKE₂
top > active₁ > nil > tt
top > active₁ > U81₂ > ok₁ > TAKE₂
top > active₁ > U82₂ > cons₂ > ok₁ > TAKE₂
top > active₁ > U91₂ > ok₁ > TAKE₂
top > active₁ > isPLNat₁ > isLNat₁ > ok₁ > TAKE₂
top > active₁ > isPLNat₁ > isLNat₁ > tt
top > active₁ > take₂ > ok₁ > TAKE₂
top > active₁ > sel₂ > ok₁ > TAKE₂

Status:

TAKE₂: multiset
ok₁: [1]
active₁: [1]
tt: multiset
fst₁: [1]
U11₃: [3,1,2]
snd₁: [1]
U21₁: [1]
U31₂: [2,1]
cons₂: [2,1]
U51₃: [3,1,2]
head₁: [1]
afterNth₂: [2,1]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₂: [1,2]
U82₂: [2,1]
U91₂: [2,1]
isLNat₁: [1]
isPLNat₁: [1]
take₂: [1,2]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(31) Obligation:

Q DP problem:
The TRS P consists of the following rules:

TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(32) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TAKE(X1, mark(X2)) → TAKE(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAKE(x1, x2)  =  TAKE(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > splitAt₂ > U71₂ > mark₁
active₁ > U101₃ > splitAt₂ > and₂ > mark₁
active₁ > tt > splitAt₂ > U71₂ > mark₁
active₁ > tt > splitAt₂ > and₂ > mark₁
active₁ > tt > cons₂ > U31₂ > mark₁
active₁ > tt > pair₂ > mark₁
active₁ > tt > nil > mark₁
active₁ > U11₃ > splitAt₂ > U71₂ > mark₁
active₁ > U11₃ > splitAt₂ > and₂ > mark₁
active₁ > U21₂ > mark₁
active₁ > U41₂ > mark₁
active₁ > U51₃ > mark₁
active₁ > head₁ > U31₂ > mark₁
active₁ > head₁ > isNatural₁ > and₂ > mark₁
active₁ > afterNth₂ > isNatural₁ > and₂ > mark₁
active₁ > U61₂ > mark₁
active₁ > U81₄ > splitAt₂ > U71₂ > mark₁
active₁ > U81₄ > splitAt₂ > and₂ > mark₁
active₁ > U82₂ > cons₂ > U31₂ > mark₁
active₁ > U82₂ > pair₂ > mark₁
active₁ > isPLNat₁ > isNatural₁ > and₂ > mark₁
active₁ > tail₁ > U91₂ > mark₁
active₁ > tail₁ > isNatural₁ > and₂ > mark₁
active₁ > take₂ > mark₁
active₁ > sel₂ > isNatural₁ > and₂ > mark₁
proper₁ > U101₃ > splitAt₂ > U71₂ > mark₁
proper₁ > U101₃ > splitAt₂ > and₂ > mark₁
proper₁ > tt > splitAt₂ > U71₂ > mark₁
proper₁ > tt > splitAt₂ > and₂ > mark₁
proper₁ > tt > cons₂ > U31₂ > mark₁
proper₁ > tt > pair₂ > mark₁
proper₁ > tt > nil > mark₁
proper₁ > U11₃ > splitAt₂ > U71₂ > mark₁
proper₁ > U11₃ > splitAt₂ > and₂ > mark₁
proper₁ > U21₂ > mark₁
proper₁ > U41₂ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > head₁ > U31₂ > mark₁
proper₁ > head₁ > isNatural₁ > and₂ > mark₁
proper₁ > afterNth₂ > isNatural₁ > and₂ > mark₁
proper₁ > U61₂ > mark₁
proper₁ > U81₄ > splitAt₂ > U71₂ > mark₁
proper₁ > U81₄ > splitAt₂ > and₂ > mark₁
proper₁ > U82₂ > cons₂ > U31₂ > mark₁
proper₁ > U82₂ > pair₂ > mark₁
proper₁ > isPLNat₁ > isNatural₁ > and₂ > mark₁
proper₁ > tail₁ > U91₂ > mark₁
proper₁ > tail₁ > isNatural₁ > and₂ > mark₁
proper₁ > take₂ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > isNatural₁ > and₂ > mark₁

Status:

TAKE₁: [1]
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
U21₂: [2,1]
U31₂: multiset
U41₂: [2,1]
cons₂: [1,2]
U51₃: [3,2,1]
head₁: [1]
afterNth₂: [1,2]
U61₂: [2,1]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [1,3,4,2]
U82₂: multiset
U91₂: [2,1]
and₂: [1,2]
isNatural₁: multiset
isPLNat₁: [1]
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(33) Obligation:

Q DP problem:
The TRS P consists of the following rules:

TAKE(mark(X1), X2) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(34) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TAKE(mark(X1), X2) → TAKE(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAKE(x1, x2)  =  TAKE(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

TAKE₂ > ok
active₁ > snd₁ > and₂ > mark₁ > ok
active₁ > U21₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > cons₂ > U31₂ > mark₁ > ok
active₁ > cons₂ > U81₄ > mark₁ > ok
active₁ > cons₂ > U91₂ > mark₁ > ok
active₁ > head₁ > U31₂ > mark₁ > ok
active₁ > head₁ > and₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > U71₂ > pair₂ > mark₁ > ok
active₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
active₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > nil > tt > pair₂ > mark₁ > ok
active₁ > nil > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
active₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > and₂ > mark₁ > ok
active₁ > isPLNat₁ > and₂ > mark₁ > ok
active₁ > tail₁ > U91₂ > mark₁ > ok
active₁ > tail₁ > and₂ > mark₁ > ok
active₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > sel₂ > U51₃ > mark₁ > ok
0 > tt > s₁ > U81₄ > mark₁ > ok
0 > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
0 > tt > pair₂ > mark₁ > ok
0 > tt > U82₂ > mark₁ > ok
0 > U71₂ > pair₂ > mark₁ > ok
proper₁ > snd₁ > and₂ > mark₁ > ok
proper₁ > U21₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > cons₂ > U31₂ > mark₁ > ok
proper₁ > cons₂ > U81₄ > mark₁ > ok
proper₁ > cons₂ > U91₂ > mark₁ > ok
proper₁ > head₁ > U31₂ > mark₁ > ok
proper₁ > head₁ > and₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > U71₂ > pair₂ > mark₁ > ok
proper₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > nil > tt > pair₂ > mark₁ > ok
proper₁ > nil > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > and₂ > mark₁ > ok
proper₁ > isPLNat₁ > and₂ > mark₁ > ok
proper₁ > tail₁ > U91₂ > mark₁ > ok
proper₁ > tail₁ > and₂ > mark₁ > ok
proper₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > sel₂ > U51₃ > mark₁ > ok
top > ok

Status:

TAKE₂: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,3,2]
tt: multiset
splitAt₂: [2,1]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
s₁: multiset
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: multiset
U91₂: [2,1]
and₂: [2,1]
isNatural₁: multiset
isPLNat₁: multiset
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(35) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(36) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(37) TRUE

(38) Obligation:

Q DP problem:
The TRS P consists of the following rules:

TAIL(ok(X)) → TAIL(X)
TAIL(mark(X)) → TAIL(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(39) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TAIL(mark(X)) → TAIL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAIL(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > splitAt₂ > mark₁
active₁ > tt > natsFrom₁ > mark₁
active₁ > U11₃ > splitAt₂ > mark₁
active₁ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > natsFrom₁ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > s₁ > mark₁
active₁ > U51₃ > mark₁
active₁ > afterNth₂ > mark₁
active₁ > U71₂ > mark₁
active₁ > pair₂ > U21₂ > mark₁
active₁ > pair₂ > U61₂ > mark₁
active₁ > nil > mark₁
active₁ > U81₄ > splitAt₂ > mark₁
active₁ > U82₂ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > U11₃ > splitAt₂ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > mark₁
proper₁ > pair₂ > U21₂ > mark₁
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U82₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > tt > fst₁ > U21₂ > mark₁
proper₁ > 0 > tt > splitAt₂ > mark₁
proper₁ > 0 > tt > natsFrom₁ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [3,1,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [3,4,1,2]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(40) Obligation:

Q DP problem:
The TRS P consists of the following rules:

TAIL(ok(X)) → TAIL(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(41) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

TAIL(ok(X)) → TAIL(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAIL(x1)  =  TAIL(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

TAIL₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

TAIL₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(42) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(43) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(44) TRUE

(45) Obligation:

Q DP problem:
The TRS P consists of the following rules:

AND(ok(X1), ok(X2)) → AND(X1, X2)
AND(mark(X1), X2) → AND(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(46) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

AND(ok(X1), ok(X2)) → AND(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AND(x1, x2)  =  x2
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  x3
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x3
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

proper₁ > U101₂ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > cons₂ > U91₂ > ok₁
proper₁ > pair₂ > U21₂ > ok₁
proper₁ > pair₂ > U61₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₃ > ok₁
proper₁ > U82₂ > ok₁
proper₁ > and₁ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > take₂ > ok₁
proper₁ > 0 > tt > afterNth₁ > ok₁
proper₁ > 0 > U71₂ > ok₁
proper₁ > sel₂ > ok₁
top > active₁ > U101₂ > ok₁
top > active₁ > tt > afterNth₁ > ok₁
top > active₁ > U31₂ > ok₁
top > active₁ > cons₂ > U91₂ > ok₁
top > active₁ > U71₂ > ok₁
top > active₁ > pair₂ > U21₂ > ok₁
top > active₁ > pair₂ > U61₂ > ok₁
top > active₁ > nil > ok₁
top > active₁ > U81₃ > ok₁
top > active₁ > U82₂ > ok₁
top > active₁ > and₁ > ok₁
top > active₁ > isNatural₁ > ok₁
top > active₁ > take₂ > ok₁
top > active₁ > sel₂ > ok₁

Status:

ok₁: [1]
active₁: multiset
U101₂: [2,1]
tt: multiset
U21₂: [2,1]
U31₂: [1,2]
cons₂: [2,1]
afterNth₁: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: [2,1]
nil: multiset
U81₃: [1,2,3]
U82₂: [1,2]
U91₂: [1,2]
and₁: multiset
isNatural₁: multiset
take₂: [2,1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(47) Obligation:

Q DP problem:
The TRS P consists of the following rules:

AND(mark(X1), X2) → AND(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(48) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

AND(mark(X1), X2) → AND(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AND(x1, x2)  =  AND(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

AND₂ > ok
active₁ > snd₁ > and₂ > mark₁ > ok
active₁ > U21₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > cons₂ > U31₂ > mark₁ > ok
active₁ > cons₂ > U81₄ > mark₁ > ok
active₁ > cons₂ > U91₂ > mark₁ > ok
active₁ > head₁ > U31₂ > mark₁ > ok
active₁ > head₁ > and₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > U71₂ > pair₂ > mark₁ > ok
active₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
active₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > nil > tt > pair₂ > mark₁ > ok
active₁ > nil > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
active₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > and₂ > mark₁ > ok
active₁ > isPLNat₁ > and₂ > mark₁ > ok
active₁ > tail₁ > U91₂ > mark₁ > ok
active₁ > tail₁ > and₂ > mark₁ > ok
active₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > sel₂ > U51₃ > mark₁ > ok
0 > tt > s₁ > U81₄ > mark₁ > ok
0 > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
0 > tt > pair₂ > mark₁ > ok
0 > tt > U82₂ > mark₁ > ok
0 > U71₂ > pair₂ > mark₁ > ok
proper₁ > snd₁ > and₂ > mark₁ > ok
proper₁ > U21₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > cons₂ > U31₂ > mark₁ > ok
proper₁ > cons₂ > U81₄ > mark₁ > ok
proper₁ > cons₂ > U91₂ > mark₁ > ok
proper₁ > head₁ > U31₂ > mark₁ > ok
proper₁ > head₁ > and₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > U71₂ > pair₂ > mark₁ > ok
proper₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > nil > tt > pair₂ > mark₁ > ok
proper₁ > nil > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > and₂ > mark₁ > ok
proper₁ > isPLNat₁ > and₂ > mark₁ > ok
proper₁ > tail₁ > U91₂ > mark₁ > ok
proper₁ > tail₁ > and₂ > mark₁ > ok
proper₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > sel₂ > U51₃ > mark₁ > ok
top > ok

Status:

AND₂: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,3,2]
tt: multiset
splitAt₂: [2,1]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
s₁: multiset
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: multiset
U91₂: [2,1]
and₂: [2,1]
isNatural₁: multiset
isPLNat₁: multiset
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(49) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(50) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(51) TRUE

(52) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U91¹(ok(X1), ok(X2)) → U91¹(X1, X2)
U91¹(mark(X1), X2) → U91¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(53) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U91¹(ok(X1), ok(X2)) → U91¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U91¹(x1, x2)  =  x2
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  x3
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x3
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

proper₁ > U101₂ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > cons₂ > U91₂ > ok₁
proper₁ > pair₂ > U21₂ > ok₁
proper₁ > pair₂ > U61₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₃ > ok₁
proper₁ > U82₂ > ok₁
proper₁ > and₁ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > take₂ > ok₁
proper₁ > 0 > tt > afterNth₁ > ok₁
proper₁ > 0 > U71₂ > ok₁
proper₁ > sel₂ > ok₁
top > active₁ > U101₂ > ok₁
top > active₁ > tt > afterNth₁ > ok₁
top > active₁ > U31₂ > ok₁
top > active₁ > cons₂ > U91₂ > ok₁
top > active₁ > U71₂ > ok₁
top > active₁ > pair₂ > U21₂ > ok₁
top > active₁ > pair₂ > U61₂ > ok₁
top > active₁ > nil > ok₁
top > active₁ > U81₃ > ok₁
top > active₁ > U82₂ > ok₁
top > active₁ > and₁ > ok₁
top > active₁ > isNatural₁ > ok₁
top > active₁ > take₂ > ok₁
top > active₁ > sel₂ > ok₁

Status:

ok₁: [1]
active₁: multiset
U101₂: [2,1]
tt: multiset
U21₂: [2,1]
U31₂: [1,2]
cons₂: [2,1]
afterNth₁: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: [2,1]
nil: multiset
U81₃: [1,2,3]
U82₂: [1,2]
U91₂: [1,2]
and₁: multiset
isNatural₁: multiset
take₂: [2,1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(54) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U91¹(mark(X1), X2) → U91¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(55) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U91¹(mark(X1), X2) → U91¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U91¹(x1, x2)  =  U91¹(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U91^1₂ > ok
active₁ > snd₁ > and₂ > mark₁ > ok
active₁ > U21₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > cons₂ > U31₂ > mark₁ > ok
active₁ > cons₂ > U81₄ > mark₁ > ok
active₁ > cons₂ > U91₂ > mark₁ > ok
active₁ > head₁ > U31₂ > mark₁ > ok
active₁ > head₁ > and₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > U71₂ > pair₂ > mark₁ > ok
active₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
active₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > nil > tt > pair₂ > mark₁ > ok
active₁ > nil > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
active₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > and₂ > mark₁ > ok
active₁ > isPLNat₁ > and₂ > mark₁ > ok
active₁ > tail₁ > U91₂ > mark₁ > ok
active₁ > tail₁ > and₂ > mark₁ > ok
active₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > sel₂ > U51₃ > mark₁ > ok
0 > tt > s₁ > U81₄ > mark₁ > ok
0 > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
0 > tt > pair₂ > mark₁ > ok
0 > tt > U82₂ > mark₁ > ok
0 > U71₂ > pair₂ > mark₁ > ok
proper₁ > snd₁ > and₂ > mark₁ > ok
proper₁ > U21₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > cons₂ > U31₂ > mark₁ > ok
proper₁ > cons₂ > U81₄ > mark₁ > ok
proper₁ > cons₂ > U91₂ > mark₁ > ok
proper₁ > head₁ > U31₂ > mark₁ > ok
proper₁ > head₁ > and₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > U71₂ > pair₂ > mark₁ > ok
proper₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > nil > tt > pair₂ > mark₁ > ok
proper₁ > nil > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > and₂ > mark₁ > ok
proper₁ > isPLNat₁ > and₂ > mark₁ > ok
proper₁ > tail₁ > U91₂ > mark₁ > ok
proper₁ > tail₁ > and₂ > mark₁ > ok
proper₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > sel₂ > U51₃ > mark₁ > ok
top > ok

Status:

U91^1₂: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,3,2]
tt: multiset
splitAt₂: [2,1]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
s₁: multiset
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: multiset
U91₂: [2,1]
and₂: [2,1]
isNatural₁: multiset
isPLNat₁: multiset
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(56) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(57) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(58) TRUE

(59) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U82¹(ok(X1), ok(X2)) → U82¹(X1, X2)
U82¹(mark(X1), X2) → U82¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(60) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U82¹(mark(X1), X2) → U82¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U82¹(x1, x2)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > snd₁ > U61₂ > mark₁
active₁ > tt > snd₁ > isLNat₁ > mark₁
active₁ > tt > cons₂ > U31₂ > mark₁
active₁ > tt > cons₂ > U81₄ > splitAt₂ > mark₁
active₁ > tt > cons₂ > U91₂ > mark₁
active₁ > tt > cons₂ > isLNat₁ > mark₁
active₁ > tt > afterNth₂ > U11₃ > splitAt₂ > mark₁
active₁ > tt > afterNth₂ > isLNat₁ > mark₁
active₁ > tt > U82₂ > pair₂ > U21₂ > mark₁
active₁ > tt > U82₂ > pair₂ > U61₂ > mark₁
active₁ > tt > U82₂ > pair₂ > isLNat₁ > mark₁
active₁ > U41₂ > cons₂ > U31₂ > mark₁
active₁ > U41₂ > cons₂ > U81₄ > splitAt₂ > mark₁
active₁ > U41₂ > cons₂ > U91₂ > mark₁
active₁ > U41₂ > cons₂ > isLNat₁ > mark₁
active₁ > s₁ > U81₄ > splitAt₂ > mark₁
active₁ > s₁ > isLNat₁ > mark₁
active₁ > U71₂ > pair₂ > U21₂ > mark₁
active₁ > U71₂ > pair₂ > U61₂ > mark₁
active₁ > U71₂ > pair₂ > isLNat₁ > mark₁
active₁ > nil > mark₁
active₁ > and₂ > mark₁
active₁ > tail₁ > U91₂ > mark₁
active₁ > tail₁ > isLNat₁ > mark₁
active₁ > take₂ > U101₃ > splitAt₂ > mark₁
active₁ > take₂ > isLNat₁ > mark₁
active₁ > sel₂ > U51₃ > mark₁
0 > mark₁
top > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [2,1,3]
snd₁: [1]
U21₂: [2,1]
U31₂: [2,1]
U41₂: [1,2]
cons₂: [1,2]
s₁: [1]
U51₃: [1,2,3]
afterNth₂: [2,1]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: [2,3,4,1]
U82₂: [2,1]
U91₂: [1,2]
and₂: [2,1]
isLNat₁: [1]
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: [2,1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(61) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U82¹(ok(X1), ok(X2)) → U82¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(62) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U82¹(ok(X1), ok(X2)) → U82¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U82¹(x1, x2)  =  U82¹(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
mark(x1)  =  x1
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  x2
U31(x1, x2)  =  U31(x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  U71(x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > splitAt₂ > ok₁
active₁ > tt > snd₁ > and₂ > ok₁
active₁ > tt > snd₁ > isLNat₁ > ok₁
active₁ > tt > cons₂ > U31₁ > ok₁
active₁ > tt > natsFrom₁ > ok₁
active₁ > tt > afterNth₂ > ok₁
active₁ > tt > pair₂ > ok₁
active₁ > tt > nil > ok₁
active₁ > tt > U82₂ > ok₁
active₁ > U11₃ > splitAt₂ > ok₁
active₁ > U51₃ > afterNth₂ > ok₁
active₁ > U71₁ > pair₂ > ok₁
active₁ > U81₄ > splitAt₂ > ok₁
active₁ > U81₄ > U82₂ > ok₁
active₁ > U91₂ > ok₁
active₁ > isNatural₁ > ok₁
active₁ > tail₁ > ok₁
active₁ > take₂ > U101₃ > splitAt₂ > ok₁
active₁ > sel₂ > ok₁
0 > U71₁ > pair₂ > ok₁
0 > isLNat₁ > ok₁
proper₁ > U11₃ > splitAt₂ > ok₁
proper₁ > snd₁ > and₂ > ok₁
proper₁ > snd₁ > isLNat₁ > ok₁
proper₁ > cons₂ > U31₁ > ok₁
proper₁ > natsFrom₁ > ok₁
proper₁ > U51₃ > afterNth₂ > ok₁
proper₁ > U71₁ > pair₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₄ > splitAt₂ > ok₁
proper₁ > U81₄ > U82₂ > ok₁
proper₁ > U91₂ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > tail₁ > ok₁
proper₁ > take₂ > U101₃ > splitAt₂ > ok₁
proper₁ > sel₂ > ok₁

Status:

U82^1₁: [1]
ok₁: [1]
active₁: [1]
U101₃: [2,3,1]
tt: multiset
splitAt₂: [2,1]
U11₃: [3,1,2]
snd₁: [1]
U31₁: [1]
cons₂: [1,2]
natsFrom₁: [1]
U51₃: multiset
afterNth₂: [1,2]
U71₁: [1]
pair₂: [2,1]
nil: multiset
U81₄: [3,2,1,4]
U82₂: [1,2]
U91₂: [1,2]
and₂: [1,2]
isNatural₁: [1]
isLNat₁: [1]
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: [2,1]
proper₁: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(63) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(64) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(65) TRUE

(66) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U81¹(ok(X1), ok(X2), ok(X3), ok(X4)) → U81¹(X1, X2, X3, X4)
U81¹(mark(X1), X2, X3, X4) → U81¹(X1, X2, X3, X4)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(67) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U81¹(mark(X1), X2, X3, X4) → U81¹(X1, X2, X3, X4)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U81¹(x1, x2, x3, x4)  =  U81¹(x1, x3)
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U81^1₂ > mark₁
active₁ > U101₃ > splitAt₂ > U71₂ > pair₂ > mark₁
active₁ > U101₃ > splitAt₂ > and₂ > mark₁
active₁ > U11₃ > splitAt₂ > U71₂ > pair₂ > mark₁
active₁ > U11₃ > splitAt₂ > and₂ > mark₁
active₁ > U41₂ > cons₂ > U31₂ > mark₁
active₁ > U41₂ > cons₂ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
active₁ > U41₂ > cons₂ > U81₄ > splitAt₂ > and₂ > mark₁
active₁ > U41₂ > cons₂ > U91₂ > mark₁
active₁ > s₁ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
active₁ > s₁ > U81₄ > splitAt₂ > and₂ > mark₁
active₁ > s₁ > isLNat₁ > and₂ > mark₁
active₁ > U51₃ > head₁ > and₂ > mark₁
active₁ > U61₂ > mark₁
active₁ > nil > tt > fst₁ > U21₂ > mark₁
active₁ > nil > tt > fst₁ > isLNat₁ > and₂ > mark₁
active₁ > nil > tt > cons₂ > U31₂ > mark₁
active₁ > nil > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
active₁ > nil > tt > cons₂ > U81₄ > splitAt₂ > and₂ > mark₁
active₁ > nil > tt > cons₂ > U91₂ > mark₁
active₁ > nil > tt > head₁ > and₂ > mark₁
active₁ > nil > tt > afterNth₂ > isLNat₁ > and₂ > mark₁
active₁ > U82₂ > cons₂ > U31₂ > mark₁
active₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
active₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > and₂ > mark₁
active₁ > U82₂ > cons₂ > U91₂ > mark₁
active₁ > tail₁ > mark₁
active₁ > take₂ > mark₁
active₁ > sel₂ > and₂ > mark₁
proper₁ > U101₃ > splitAt₂ > U71₂ > pair₂ > mark₁
proper₁ > U101₃ > splitAt₂ > and₂ > mark₁
proper₁ > U11₃ > splitAt₂ > U71₂ > pair₂ > mark₁
proper₁ > U11₃ > splitAt₂ > and₂ > mark₁
proper₁ > U41₂ > cons₂ > U31₂ > mark₁
proper₁ > U41₂ > cons₂ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
proper₁ > U41₂ > cons₂ > U81₄ > splitAt₂ > and₂ > mark₁
proper₁ > U41₂ > cons₂ > U91₂ > mark₁
proper₁ > s₁ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
proper₁ > s₁ > U81₄ > splitAt₂ > and₂ > mark₁
proper₁ > s₁ > isLNat₁ > and₂ > mark₁
proper₁ > U51₃ > head₁ > and₂ > mark₁
proper₁ > U61₂ > mark₁
proper₁ > nil > tt > fst₁ > U21₂ > mark₁
proper₁ > nil > tt > fst₁ > isLNat₁ > and₂ > mark₁
proper₁ > nil > tt > cons₂ > U31₂ > mark₁
proper₁ > nil > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
proper₁ > nil > tt > cons₂ > U81₄ > splitAt₂ > and₂ > mark₁
proper₁ > nil > tt > cons₂ > U91₂ > mark₁
proper₁ > nil > tt > head₁ > and₂ > mark₁
proper₁ > nil > tt > afterNth₂ > isLNat₁ > and₂ > mark₁
proper₁ > U82₂ > cons₂ > U31₂ > mark₁
proper₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > U71₂ > pair₂ > mark₁
proper₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > and₂ > mark₁
proper₁ > U82₂ > cons₂ > U91₂ > mark₁
proper₁ > tail₁ > mark₁
proper₁ > take₂ > mark₁
proper₁ > 0 > U71₂ > pair₂ > mark₁
proper₁ > 0 > isLNat₁ > and₂ > mark₁
proper₁ > sel₂ > and₂ > mark₁
top > mark₁

Status:

U81^1₂: [1,2]
mark₁: [1]
active₁: [1]
U101₃: [2,3,1]
tt: multiset
fst₁: multiset
splitAt₂: [2,1]
U11₃: [1,3,2]
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [2,1]
s₁: [1]
U51₃: [3,2,1]
head₁: [1]
afterNth₂: [2,1]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [2,1]
nil: multiset
U81₄: [4,3,2,1]
U82₂: [2,1]
U91₂: [1,2]
and₂: [1,2]
isLNat₁: multiset
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(68) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U81¹(ok(X1), ok(X2), ok(X3), ok(X4)) → U81¹(X1, X2, X3, X4)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(69) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U81¹(ok(X1), ok(X2), ok(X3), ok(X4)) → U81¹(X1, X2, X3, X4)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U81¹(x1, x2, x3, x4)  =  U81¹(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
mark(x1)  =  mark(x1)
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U81^1₁ > top
active₁ > U101₃ > fst₁ > U21₂ > ok₁ > top
active₁ > U101₃ > fst₁ > U21₂ > mark₁ > top
active₁ > U101₃ > fst₁ > and₂ > ok₁ > top
active₁ > U101₃ > fst₁ > and₂ > mark₁ > top
active₁ > U101₃ > splitAt₂ > ok₁ > top
active₁ > U101₃ > splitAt₂ > mark₁ > top
active₁ > U31₂ > ok₁ > top
active₁ > U31₂ > mark₁ > top
active₁ > U41₂ > ok₁ > top
active₁ > U41₂ > mark₁ > top
active₁ > s₁ > ok₁ > top
active₁ > s₁ > mark₁ > top
active₁ > afterNth₂ > U11₃ > ok₁ > top
active₁ > afterNth₂ > U11₃ > mark₁ > top
active₁ > afterNth₂ > and₂ > ok₁ > top
active₁ > afterNth₂ > and₂ > mark₁ > top
active₁ > U61₂ > ok₁ > top
active₁ > U61₂ > mark₁ > top
active₁ > U71₂ > pair₂ > U21₂ > ok₁ > top
active₁ > U71₂ > pair₂ > U21₂ > mark₁ > top
active₁ > nil > ok₁ > top
active₁ > nil > tt > top
active₁ > nil > mark₁ > top
active₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > ok₁ > top
active₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > mark₁ > top
active₁ > U82₂ > cons₂ > U91₂ > ok₁ > top
active₁ > U82₂ > cons₂ > U91₂ > mark₁ > top
active₁ > U82₂ > cons₂ > and₂ > ok₁ > top
active₁ > U82₂ > cons₂ > and₂ > mark₁ > top
active₁ > U82₂ > pair₂ > U21₂ > ok₁ > top
active₁ > U82₂ > pair₂ > U21₂ > mark₁ > top
active₁ > isNatural₁ > isLNat₁ > tt > top
active₁ > isNatural₁ > isLNat₁ > and₂ > ok₁ > top
active₁ > isNatural₁ > isLNat₁ > and₂ > mark₁ > top
active₁ > tail₁ > U91₂ > ok₁ > top
active₁ > tail₁ > U91₂ > mark₁ > top
active₁ > tail₁ > and₂ > ok₁ > top
active₁ > tail₁ > and₂ > mark₁ > top
active₁ > take₂ > ok₁ > top
active₁ > take₂ > mark₁ > top
active₁ > sel₂ > U51₃ > ok₁ > top
active₁ > sel₂ > U51₃ > mark₁ > top
active₁ > sel₂ > and₂ > ok₁ > top
active₁ > sel₂ > and₂ > mark₁ > top
proper₁ > U101₃ > fst₁ > U21₂ > ok₁ > top
proper₁ > U101₃ > fst₁ > U21₂ > mark₁ > top
proper₁ > U101₃ > fst₁ > and₂ > ok₁ > top
proper₁ > U101₃ > fst₁ > and₂ > mark₁ > top
proper₁ > U101₃ > splitAt₂ > ok₁ > top
proper₁ > U101₃ > splitAt₂ > mark₁ > top
proper₁ > U31₂ > ok₁ > top
proper₁ > U31₂ > mark₁ > top
proper₁ > U41₂ > ok₁ > top
proper₁ > U41₂ > mark₁ > top
proper₁ > s₁ > ok₁ > top
proper₁ > s₁ > mark₁ > top
proper₁ > afterNth₂ > U11₃ > ok₁ > top
proper₁ > afterNth₂ > U11₃ > mark₁ > top
proper₁ > afterNth₂ > and₂ > ok₁ > top
proper₁ > afterNth₂ > and₂ > mark₁ > top
proper₁ > U61₂ > ok₁ > top
proper₁ > U61₂ > mark₁ > top
proper₁ > U71₂ > pair₂ > U21₂ > ok₁ > top
proper₁ > U71₂ > pair₂ > U21₂ > mark₁ > top
proper₁ > nil > ok₁ > top
proper₁ > nil > tt > top
proper₁ > nil > mark₁ > top
proper₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > ok₁ > top
proper₁ > U82₂ > cons₂ > U81₄ > splitAt₂ > mark₁ > top
proper₁ > U82₂ > cons₂ > U91₂ > ok₁ > top
proper₁ > U82₂ > cons₂ > U91₂ > mark₁ > top
proper₁ > U82₂ > cons₂ > and₂ > ok₁ > top
proper₁ > U82₂ > cons₂ > and₂ > mark₁ > top
proper₁ > U82₂ > pair₂ > U21₂ > ok₁ > top
proper₁ > U82₂ > pair₂ > U21₂ > mark₁ > top
proper₁ > isNatural₁ > isLNat₁ > tt > top
proper₁ > isNatural₁ > isLNat₁ > and₂ > ok₁ > top
proper₁ > isNatural₁ > isLNat₁ > and₂ > mark₁ > top
proper₁ > tail₁ > U91₂ > ok₁ > top
proper₁ > tail₁ > U91₂ > mark₁ > top
proper₁ > tail₁ > and₂ > ok₁ > top
proper₁ > tail₁ > and₂ > mark₁ > top
proper₁ > take₂ > ok₁ > top
proper₁ > take₂ > mark₁ > top
proper₁ > 0 > tt > top
proper₁ > sel₂ > U51₃ > ok₁ > top
proper₁ > sel₂ > U51₃ > mark₁ > top
proper₁ > sel₂ > and₂ > ok₁ > top
proper₁ > sel₂ > and₂ > mark₁ > top

Status:

U81^1₁: multiset
ok₁: [1]
active₁: [1]
U101₃: [3,2,1]
tt: multiset
mark₁: multiset
fst₁: [1]
splitAt₂: [2,1]
U11₃: [1,3,2]
U21₂: multiset
U31₂: [2,1]
U41₂: [1,2]
cons₂: [1,2]
s₁: [1]
U51₃: [2,1,3]
afterNth₂: [1,2]
U61₂: [2,1]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: [2,1,4,3]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
isNatural₁: multiset
isLNat₁: multiset
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(70) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(71) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(72) TRUE

(73) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PAIR(X1, mark(X2)) → PAIR(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)
PAIR(ok(X1), ok(X2)) → PAIR(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(74) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PAIR(ok(X1), ok(X2)) → PAIR(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PAIR(x1, x2)  =  PAIR(x1, x2)
mark(x1)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  x3
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > ok₁
active₁ > fst₁ > ok₁
active₁ > U31₂ > ok₁
active₁ > cons₂ > U81₂ > ok₁
active₁ > cons₂ > isLNat₁ > and₁ > ok₁
active₁ > cons₂ > isLNat₁ > isNatural₁ > tt > pair₂ > ok₁
active₁ > s₁ > U81₂ > ok₁
active₁ > U51₃ > ok₁
active₁ > head₁ > and₁ > ok₁
active₁ > head₁ > isNatural₁ > tt > pair₂ > ok₁
active₁ > U61₂ > ok₁
active₁ > U71₂ > pair₂ > ok₁
active₁ > nil > tt > pair₂ > ok₁
active₁ > U82₂ > pair₂ > ok₁
active₁ > isPLNat₁ > and₁ > ok₁
active₁ > isPLNat₁ > isNatural₁ > tt > pair₂ > ok₁
active₁ > tail₁ > ok₁
active₁ > take₂ > ok₁
active₁ > sel₂ > ok₁
proper₁ > U101₃ > ok₁
proper₁ > fst₁ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > cons₂ > U81₂ > ok₁
proper₁ > cons₂ > isLNat₁ > and₁ > ok₁
proper₁ > cons₂ > isLNat₁ > isNatural₁ > tt > pair₂ > ok₁
proper₁ > s₁ > U81₂ > ok₁
proper₁ > U51₃ > ok₁
proper₁ > head₁ > and₁ > ok₁
proper₁ > head₁ > isNatural₁ > tt > pair₂ > ok₁
proper₁ > U61₂ > ok₁
proper₁ > U71₂ > pair₂ > ok₁
proper₁ > nil > tt > pair₂ > ok₁
proper₁ > U82₂ > pair₂ > ok₁
proper₁ > isPLNat₁ > and₁ > ok₁
proper₁ > isPLNat₁ > isNatural₁ > tt > pair₂ > ok₁
proper₁ > tail₁ > ok₁
proper₁ > take₂ > ok₁
proper₁ > 0 > ok₁
proper₁ > sel₂ > ok₁

Status:

PAIR₂: [2,1]
ok₁: [1]
active₁: [1]
U101₃: [2,1,3]
tt: multiset
fst₁: [1]
U31₂: [1,2]
cons₂: [1,2]
s₁: multiset
U51₃: [2,3,1]
head₁: [1]
U61₂: [2,1]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₂: [1,2]
U82₂: [1,2]
and₁: [1]
isNatural₁: [1]
isLNat₁: [1]
isPLNat₁: [1]
tail₁: [1]
take₂: [2,1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(75) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PAIR(X1, mark(X2)) → PAIR(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(76) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PAIR(X1, mark(X2)) → PAIR(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PAIR(x1, x2)  =  PAIR(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  x1
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > splitAt₂ > U81₄ > mark₁ > PAIR₂
active₁ > U101₃ > splitAt₂ > U81₄ > ok > PAIR₂
active₁ > U101₃ > splitAt₂ > and₂ > mark₁ > PAIR₂
active₁ > U101₃ > splitAt₂ > and₂ > ok > PAIR₂
active₁ > U11₃ > splitAt₂ > U81₄ > mark₁ > PAIR₂
active₁ > U11₃ > splitAt₂ > U81₄ > ok > PAIR₂
active₁ > U11₃ > splitAt₂ > and₂ > mark₁ > PAIR₂
active₁ > U11₃ > splitAt₂ > and₂ > ok > PAIR₂
active₁ > U21₂ > mark₁ > PAIR₂
active₁ > U21₂ > ok > PAIR₂
active₁ > U31₂ > mark₁ > PAIR₂
active₁ > U31₂ > ok > PAIR₂
active₁ > U41₂ > cons₂ > mark₁ > PAIR₂
active₁ > U41₂ > cons₂ > ok > PAIR₂
active₁ > natsFrom₁ > mark₁ > PAIR₂
active₁ > natsFrom₁ > ok > PAIR₂
active₁ > afterNth₂ > and₂ > mark₁ > PAIR₂
active₁ > afterNth₂ > and₂ > ok > PAIR₂
active₁ > U61₂ > mark₁ > PAIR₂
active₁ > U61₂ > ok > PAIR₂
active₁ > U71₂ > pair₂ > mark₁ > PAIR₂
active₁ > U71₂ > pair₂ > ok > PAIR₂
active₁ > U71₂ > nil > tt > mark₁ > PAIR₂
active₁ > U71₂ > nil > tt > ok > PAIR₂
active₁ > U82₂ > cons₂ > mark₁ > PAIR₂
active₁ > U82₂ > cons₂ > ok > PAIR₂
active₁ > U82₂ > pair₂ > mark₁ > PAIR₂
active₁ > U82₂ > pair₂ > ok > PAIR₂
active₁ > isNatural₁ > tt > mark₁ > PAIR₂
active₁ > isNatural₁ > tt > ok > PAIR₂
active₁ > isNatural₁ > and₂ > mark₁ > PAIR₂
active₁ > isNatural₁ > and₂ > ok > PAIR₂
active₁ > tail₁ > U91₂ > mark₁ > PAIR₂
active₁ > tail₁ > U91₂ > ok > PAIR₂
active₁ > tail₁ > and₂ > mark₁ > PAIR₂
active₁ > tail₁ > and₂ > ok > PAIR₂
active₁ > take₂ > mark₁ > PAIR₂
active₁ > take₂ > ok > PAIR₂
active₁ > sel₂ > U51₃ > mark₁ > PAIR₂
active₁ > sel₂ > U51₃ > ok > PAIR₂
active₁ > sel₂ > and₂ > mark₁ > PAIR₂
active₁ > sel₂ > and₂ > ok > PAIR₂
0 > tt > mark₁ > PAIR₂
0 > tt > ok > PAIR₂
top > PAIR₂

Status:

PAIR₂: [2,1]
mark₁: [1]
active₁: [1]
U101₃: [2,1,3]
tt: multiset
splitAt₂: [2,1]
U11₃: [3,2,1]
U21₂: [2,1]
U31₂: multiset
U41₂: [2,1]
cons₂: [2,1]
natsFrom₁: [1]
U51₃: [1,2,3]
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: multiset
pair₂: [1,2]
nil: multiset
U81₄: [1,3,2,4]
U82₂: [2,1]
U91₂: [1,2]
and₂: multiset
isNatural₁: [1]
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: [1,2]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(77) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(78) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(79) TRUE

(80) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U71¹(ok(X1), ok(X2)) → U71¹(X1, X2)
U71¹(mark(X1), X2) → U71¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(81) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U71¹(ok(X1), ok(X2)) → U71¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U71¹(x1, x2)  =  U71¹(x1)
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  U11(x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₁ > ok₁
active₁ > tt > fst₁ > ok₁
active₁ > tt > snd₁ > ok₁
active₁ > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
active₁ > tt > head₁ > ok₁
active₁ > tt > U82₂ > cons₂ > ok₁
active₁ > U11₁ > snd₁ > ok₁
active₁ > U31₂ > ok₁
active₁ > afterNth₂ > ok₁
active₁ > U71₂ > ok₁
active₁ > pair₂ > U21₂ > ok₁
active₁ > pair₂ > cons₂ > ok₁
active₁ > nil > ok₁
active₁ > U81₂ > U82₂ > cons₂ > ok₁
active₁ > and₁ > ok₁
active₁ > isNatural₁ > ok₁
active₁ > isLNat₁ > ok₁
active₁ > tail₁ > ok₁
active₁ > sel₂ > U51₃ > head₁ > ok₁
0 > tt > fst₁ > ok₁
0 > tt > snd₁ > ok₁
0 > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
0 > tt > head₁ > ok₁
0 > tt > U82₂ > cons₂ > ok₁
0 > U71₂ > ok₁
0 > isLNat₁ > ok₁
proper₁ > U101₁ > ok₁
proper₁ > tt > fst₁ > ok₁
proper₁ > tt > snd₁ > ok₁
proper₁ > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
proper₁ > tt > head₁ > ok₁
proper₁ > tt > U82₂ > cons₂ > ok₁
proper₁ > U11₁ > snd₁ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > afterNth₂ > ok₁
proper₁ > U71₂ > ok₁
proper₁ > pair₂ > U21₂ > ok₁
proper₁ > pair₂ > cons₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₂ > U82₂ > cons₂ > ok₁
proper₁ > and₁ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > isLNat₁ > ok₁
proper₁ > tail₁ > ok₁
proper₁ > sel₂ > U51₃ > head₁ > ok₁

Status:

U71^1₁: multiset
ok₁: [1]
active₁: [1]
U101₁: [1]
tt: multiset
fst₁: [1]
U11₁: [1]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
U51₃: [1,2,3]
head₁: [1]
afterNth₂: [2,1]
U71₂: [2,1]
pair₂: [2,1]
nil: multiset
U81₂: [1,2]
U82₂: [1,2]
and₁: [1]
isNatural₁: [1]
isLNat₁: [1]
tail₁: [1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(82) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U71¹(mark(X1), X2) → U71¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(83) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U71¹(mark(X1), X2) → U71¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U71¹(x1, x2)  =  U71¹(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U71^1₁ > ok
active₁ > U101₃ > splitAt₂ > U71₂ > mark₁ > ok
active₁ > tt > snd₁ > isPLNat₁ > mark₁ > ok
active₁ > tt > cons₂ > U31₂ > mark₁ > ok
active₁ > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > mark₁ > ok
active₁ > tt > cons₂ > U91₂ > mark₁ > ok
active₁ > tt > afterNth₂ > U11₃ > mark₁ > ok
active₁ > tt > pair₂ > U21₂ > mark₁ > ok
active₁ > tt > nil > mark₁ > ok
active₁ > tt > U82₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > and₂ > mark₁ > ok
active₁ > take₂ > mark₁ > ok
active₁ > sel₂ > U51₃ > afterNth₂ > U11₃ > mark₁ > ok
proper₁ > U101₃ > splitAt₂ > U71₂ > mark₁ > ok
proper₁ > tt > snd₁ > isPLNat₁ > mark₁ > ok
proper₁ > tt > cons₂ > U31₂ > mark₁ > ok
proper₁ > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > mark₁ > ok
proper₁ > tt > cons₂ > U91₂ > mark₁ > ok
proper₁ > tt > afterNth₂ > U11₃ > mark₁ > ok
proper₁ > tt > pair₂ > U21₂ > mark₁ > ok
proper₁ > tt > nil > mark₁ > ok
proper₁ > tt > U82₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > and₂ > mark₁ > ok
proper₁ > take₂ > mark₁ > ok
proper₁ > 0 > mark₁ > ok
proper₁ > sel₂ > U51₃ > afterNth₂ > U11₃ > mark₁ > ok
top > ok

Status:

U71^1₁: [1]
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [2,1]
U51₃: multiset
afterNth₂: [2,1]
U61₂: [2,1]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: [2,1]
U91₂: [2,1]
and₂: [2,1]
isPLNat₁: multiset
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(84) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(85) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(86) TRUE

(87) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(ok(X1), ok(X2)) → U61¹(X1, X2)
U61¹(mark(X1), X2) → U61¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(88) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U61¹(ok(X1), ok(X2)) → U61¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U61¹(x1, x2)  =  U61¹(x1)
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  U11(x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₁ > ok₁
active₁ > tt > fst₁ > ok₁
active₁ > tt > snd₁ > ok₁
active₁ > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
active₁ > tt > head₁ > ok₁
active₁ > tt > U82₂ > cons₂ > ok₁
active₁ > U11₁ > snd₁ > ok₁
active₁ > U31₂ > ok₁
active₁ > afterNth₂ > ok₁
active₁ > U71₂ > ok₁
active₁ > pair₂ > U21₂ > ok₁
active₁ > pair₂ > cons₂ > ok₁
active₁ > nil > ok₁
active₁ > U81₂ > U82₂ > cons₂ > ok₁
active₁ > and₁ > ok₁
active₁ > isNatural₁ > ok₁
active₁ > isLNat₁ > ok₁
active₁ > tail₁ > ok₁
active₁ > sel₂ > U51₃ > head₁ > ok₁
0 > tt > fst₁ > ok₁
0 > tt > snd₁ > ok₁
0 > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
0 > tt > head₁ > ok₁
0 > tt > U82₂ > cons₂ > ok₁
0 > U71₂ > ok₁
0 > isLNat₁ > ok₁
proper₁ > U101₁ > ok₁
proper₁ > tt > fst₁ > ok₁
proper₁ > tt > snd₁ > ok₁
proper₁ > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
proper₁ > tt > head₁ > ok₁
proper₁ > tt > U82₂ > cons₂ > ok₁
proper₁ > U11₁ > snd₁ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > afterNth₂ > ok₁
proper₁ > U71₂ > ok₁
proper₁ > pair₂ > U21₂ > ok₁
proper₁ > pair₂ > cons₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₂ > U82₂ > cons₂ > ok₁
proper₁ > and₁ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > isLNat₁ > ok₁
proper₁ > tail₁ > ok₁
proper₁ > sel₂ > U51₃ > head₁ > ok₁

Status:

U61^1₁: multiset
ok₁: [1]
active₁: [1]
U101₁: [1]
tt: multiset
fst₁: [1]
U11₁: [1]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
U51₃: [1,2,3]
head₁: [1]
afterNth₂: [2,1]
U71₂: [2,1]
pair₂: [2,1]
nil: multiset
U81₂: [1,2]
U82₂: [1,2]
and₁: [1]
isNatural₁: [1]
isLNat₁: [1]
tail₁: [1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(89) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(mark(X1), X2) → U61¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(90) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U61¹(mark(X1), X2) → U61¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U61¹(x1, x2)  =  U61¹(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U61^1₁ > ok
active₁ > U101₃ > splitAt₂ > U71₂ > mark₁ > ok
active₁ > tt > snd₁ > isPLNat₁ > mark₁ > ok
active₁ > tt > cons₂ > U31₂ > mark₁ > ok
active₁ > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > mark₁ > ok
active₁ > tt > cons₂ > U91₂ > mark₁ > ok
active₁ > tt > afterNth₂ > U11₃ > mark₁ > ok
active₁ > tt > pair₂ > U21₂ > mark₁ > ok
active₁ > tt > nil > mark₁ > ok
active₁ > tt > U82₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > and₂ > mark₁ > ok
active₁ > take₂ > mark₁ > ok
active₁ > sel₂ > U51₃ > afterNth₂ > U11₃ > mark₁ > ok
proper₁ > U101₃ > splitAt₂ > U71₂ > mark₁ > ok
proper₁ > tt > snd₁ > isPLNat₁ > mark₁ > ok
proper₁ > tt > cons₂ > U31₂ > mark₁ > ok
proper₁ > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > mark₁ > ok
proper₁ > tt > cons₂ > U91₂ > mark₁ > ok
proper₁ > tt > afterNth₂ > U11₃ > mark₁ > ok
proper₁ > tt > pair₂ > U21₂ > mark₁ > ok
proper₁ > tt > nil > mark₁ > ok
proper₁ > tt > U82₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > and₂ > mark₁ > ok
proper₁ > take₂ > mark₁ > ok
proper₁ > 0 > mark₁ > ok
proper₁ > sel₂ > U51₃ > afterNth₂ > U11₃ > mark₁ > ok
top > ok

Status:

U61^1₁: [1]
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [2,1]
U51₃: multiset
afterNth₂: [2,1]
U61₂: [2,1]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: [2,1]
U91₂: [2,1]
and₂: [2,1]
isPLNat₁: multiset
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(91) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(92) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(93) TRUE

(94) Obligation:

Q DP problem:
The TRS P consists of the following rules:

AFTERNTH(X1, mark(X2)) → AFTERNTH(X1, X2)
AFTERNTH(mark(X1), X2) → AFTERNTH(X1, X2)
AFTERNTH(ok(X1), ok(X2)) → AFTERNTH(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(95) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

AFTERNTH(X1, mark(X2)) → AFTERNTH(X1, X2)
AFTERNTH(mark(X1), X2) → AFTERNTH(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AFTERNTH(x1, x2)  =  AFTERNTH(x1, x2)
mark(x1)  =  mark(x1)
ok(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

AFTERNTH₂ > mark₁
active₁ > U101₃ > mark₁
active₁ > tt > afterNth₂ > mark₁
active₁ > tt > pair₂ > U61₂ > mark₁
active₁ > tt > nil > mark₁
active₁ > splitAt₂ > U71₂ > pair₂ > U61₂ > mark₁
active₁ > splitAt₂ > U71₂ > nil > mark₁
active₁ > splitAt₂ > U81₄ > mark₁
active₁ > U11₃ > mark₁
active₁ > U21₂ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > cons₂ > U81₄ > mark₁
active₁ > cons₂ > U91₂ > mark₁
active₁ > natsFrom₁ > U41₂ > mark₁
active₁ > U82₂ > pair₂ > U61₂ > mark₁
active₁ > and₂ > mark₁
active₁ > isLNat₁ > isPLNat₁ > mark₁
active₁ > take₂ > mark₁
active₁ > sel₂ > U51₃ > afterNth₂ > mark₁
proper₁ > U101₃ > mark₁
proper₁ > tt > afterNth₂ > mark₁
proper₁ > tt > pair₂ > U61₂ > mark₁
proper₁ > tt > nil > mark₁
proper₁ > splitAt₂ > U71₂ > pair₂ > U61₂ > mark₁
proper₁ > splitAt₂ > U71₂ > nil > mark₁
proper₁ > splitAt₂ > U81₄ > mark₁
proper₁ > U11₃ > mark₁
proper₁ > U21₂ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > cons₂ > U81₄ > mark₁
proper₁ > cons₂ > U91₂ > mark₁
proper₁ > natsFrom₁ > U41₂ > mark₁
proper₁ > U82₂ > pair₂ > U61₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > isLNat₁ > isPLNat₁ > mark₁
proper₁ > take₂ > mark₁
proper₁ > 0 > mark₁
proper₁ > sel₂ > U51₃ > afterNth₂ > mark₁
top > mark₁

Status:

AFTERNTH₂: [1,2]
mark₁: [1]
active₁: [1]
U101₃: [1,3,2]
tt: multiset
splitAt₂: [1,2]
U11₃: [2,3,1]
U21₂: [1,2]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
natsFrom₁: [1]
U51₃: [3,1,2]
afterNth₂: [1,2]
U61₂: [2,1]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: [3,1,4,2]
U82₂: multiset
U91₂: [1,2]
and₂: [2,1]
isLNat₁: [1]
isPLNat₁: multiset
take₂: [1,2]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(96) Obligation:

Q DP problem:
The TRS P consists of the following rules:

AFTERNTH(ok(X1), ok(X2)) → AFTERNTH(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(97) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

AFTERNTH(ok(X1), ok(X2)) → AFTERNTH(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AFTERNTH(x1, x2)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x3)
tt  =  tt
mark(x1)  =  x1
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x2)
U11(x1, x2, x3)  =  U11(x1, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x2
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x2)
and(x1, x2)  =  and(x2)
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₁ > ok₁
active₁ > splitAt₁ > U81₃ > U82₂ > pair₂ > U21₂ > ok₁
active₁ > splitAt₁ > isLNat₁ > and₁ > ok₁
active₁ > U11₂ > snd₁ > ok₁
active₁ > U31₂ > ok₁
active₁ > U41₁ > cons₂ > isLNat₁ > and₁ > ok₁
active₁ > U41₁ > s₁ > ok₁
active₁ > U51₂ > ok₁
active₁ > nil > tt > snd₁ > ok₁
active₁ > nil > tt > s₁ > ok₁
active₁ > nil > tt > head₁ > ok₁
active₁ > nil > tt > U82₂ > pair₂ > U21₂ > ok₁
active₁ > U91₁ > ok₁
active₁ > isPLNat₁ > isLNat₁ > and₁ > ok₁
active₁ > sel₂ > ok₁
0 > tt > snd₁ > ok₁
0 > tt > s₁ > ok₁
0 > tt > head₁ > ok₁
0 > tt > U82₂ > pair₂ > U21₂ > ok₁
0 > isLNat₁ > and₁ > ok₁
proper₁ > U101₁ > ok₁
proper₁ > tt > snd₁ > ok₁
proper₁ > tt > s₁ > ok₁
proper₁ > tt > head₁ > ok₁
proper₁ > tt > U82₂ > pair₂ > U21₂ > ok₁
proper₁ > splitAt₁ > U81₃ > U82₂ > pair₂ > U21₂ > ok₁
proper₁ > splitAt₁ > isLNat₁ > and₁ > ok₁
proper₁ > U11₂ > snd₁ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > U41₁ > cons₂ > isLNat₁ > and₁ > ok₁
proper₁ > U41₁ > s₁ > ok₁
proper₁ > U51₂ > ok₁
proper₁ > U91₁ > ok₁
proper₁ > isPLNat₁ > isLNat₁ > and₁ > ok₁
proper₁ > sel₂ > ok₁
top > ok₁

Status:

ok₁: [1]
active₁: [1]
U101₁: [1]
tt: multiset
splitAt₁: [1]
U11₂: multiset
snd₁: [1]
U21₂: [1,2]
U31₂: [2,1]
U41₁: [1]
cons₂: [2,1]
s₁: [1]
U51₂: [2,1]
head₁: [1]
pair₂: [2,1]
nil: multiset
U81₃: [1,2,3]
U82₂: [2,1]
U91₁: [1]
and₁: multiset
isLNat₁: multiset
isPLNat₁: [1]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(98) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(99) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(100) TRUE

(101) Obligation:

Q DP problem:
The TRS P consists of the following rules:

HEAD(ok(X)) → HEAD(X)
HEAD(mark(X)) → HEAD(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(102) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

HEAD(mark(X)) → HEAD(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
HEAD(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > splitAt₂ > mark₁
active₁ > tt > natsFrom₁ > mark₁
active₁ > U11₃ > splitAt₂ > mark₁
active₁ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > natsFrom₁ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > s₁ > mark₁
active₁ > U51₃ > mark₁
active₁ > afterNth₂ > mark₁
active₁ > U71₂ > mark₁
active₁ > pair₂ > U21₂ > mark₁
active₁ > pair₂ > U61₂ > mark₁
active₁ > nil > mark₁
active₁ > U81₄ > splitAt₂ > mark₁
active₁ > U82₂ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > U11₃ > splitAt₂ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > mark₁
proper₁ > pair₂ > U21₂ > mark₁
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U82₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > tt > fst₁ > U21₂ > mark₁
proper₁ > 0 > tt > splitAt₂ > mark₁
proper₁ > 0 > tt > natsFrom₁ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [3,1,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [3,4,1,2]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(103) Obligation:

Q DP problem:
The TRS P consists of the following rules:

HEAD(ok(X)) → HEAD(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(104) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

HEAD(ok(X)) → HEAD(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
HEAD(x1)  =  HEAD(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

HEAD₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

HEAD₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(105) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(106) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(107) TRUE

(108) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U51¹(ok(X1), ok(X2), ok(X3)) → U51¹(X1, X2, X3)
U51¹(mark(X1), X2, X3) → U51¹(X1, X2, X3)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(109) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U51¹(mark(X1), X2, X3) → U51¹(X1, X2, X3)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U51¹(x1, x2, x3)  =  U51¹(x1, x2, x3)
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U51^1₃ > mark₁
active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > fst₁ > isLNat₁ > mark₁
active₁ > tt > splitAt₂ > U71₂ > mark₁
active₁ > tt > splitAt₂ > isLNat₁ > mark₁
active₁ > tt > snd₁ > U61₂ > mark₁
active₁ > tt > head₁ > U31₂ > mark₁
active₁ > tt > head₁ > isLNat₁ > mark₁
active₁ > tt > afterNth₂ > mark₁
active₁ > tt > nil > mark₁
active₁ > tt > U82₂ > cons₂ > mark₁
active₁ > tt > U82₂ > pair₂ > U61₂ > mark₁
active₁ > U11₃ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > cons₂ > mark₁
active₁ > U51₃ > afterNth₂ > mark₁
active₁ > U81₄ > splitAt₂ > U71₂ > mark₁
active₁ > U81₄ > splitAt₂ > isLNat₁ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > fst₁ > U21₂ > mark₁
proper₁ > fst₁ > isLNat₁ > mark₁
proper₁ > U11₃ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > cons₂ > mark₁
proper₁ > U51₃ > afterNth₂ > mark₁
proper₁ > head₁ > U31₂ > mark₁
proper₁ > head₁ > isLNat₁ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > U71₂ > mark₁
proper₁ > U81₄ > splitAt₂ > isLNat₁ > mark₁
proper₁ > U82₂ > cons₂ > mark₁
proper₁ > U82₂ > pair₂ > U61₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > mark₁
proper₁ > sel₂ > mark₁
top > mark₁

Status:

U51^1₃: multiset
mark₁: [1]
active₁: [1]
U101₃: [2,3,1]
tt: multiset
fst₁: [1]
splitAt₂: [2,1]
U11₃: [1,3,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
U51₃: [2,1,3]
head₁: [1]
afterNth₂: [2,1]
U61₂: [1,2]
U71₂: [1,2]
pair₂: [2,1]
nil: multiset
U81₄: [1,3,4,2]
U82₂: [1,2]
U91₂: [2,1]
and₂: [2,1]
isLNat₁: multiset
take₂: [1,2]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(110) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U51¹(ok(X1), ok(X2), ok(X3)) → U51¹(X1, X2, X3)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(111) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U51¹(ok(X1), ok(X2), ok(X3)) → U51¹(X1, X2, X3)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U51¹(x1, x2, x3)  =  U51¹(x1, x2, x3)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x1
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x1
snd(x1)  =  x1
U21(x1, x2)  =  x1
U31(x1, x2)  =  x1
U41(x1, x2)  =  x1
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x1
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x2
and(x1, x2)  =  x1
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U51^1₃ > mark
active₁ > tt > ok₁ > mark
active₁ > tt > nil > mark
proper > tt > ok₁ > mark
proper > tt > nil > mark
proper > 0 > mark
top > mark

Status:

U51^1₃: multiset
ok₁: [1]
active₁: [1]
tt: multiset
mark: []
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(112) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(113) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(114) TRUE

(115) Obligation:

Q DP problem:
The TRS P consists of the following rules:

S(ok(X)) → S(X)
S(mark(X)) → S(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(116) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

S(mark(X)) → S(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
S(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > splitAt₂ > mark₁
active₁ > tt > natsFrom₁ > mark₁
active₁ > U11₃ > splitAt₂ > mark₁
active₁ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > natsFrom₁ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > s₁ > mark₁
active₁ > U51₃ > mark₁
active₁ > afterNth₂ > mark₁
active₁ > U71₂ > mark₁
active₁ > pair₂ > U21₂ > mark₁
active₁ > pair₂ > U61₂ > mark₁
active₁ > nil > mark₁
active₁ > U81₄ > splitAt₂ > mark₁
active₁ > U82₂ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > U11₃ > splitAt₂ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > mark₁
proper₁ > pair₂ > U21₂ > mark₁
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U82₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > tt > fst₁ > U21₂ > mark₁
proper₁ > 0 > tt > splitAt₂ > mark₁
proper₁ > 0 > tt > natsFrom₁ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [3,1,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [3,4,1,2]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(117) Obligation:

Q DP problem:
The TRS P consists of the following rules:

S(ok(X)) → S(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(118) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

S(ok(X)) → S(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
S(x1)  =  S(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

S₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

S₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(119) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(120) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(121) TRUE

(122) Obligation:

Q DP problem:
The TRS P consists of the following rules:

NATSFROM(ok(X)) → NATSFROM(X)
NATSFROM(mark(X)) → NATSFROM(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(123) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

NATSFROM(mark(X)) → NATSFROM(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
NATSFROM(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > splitAt₂ > mark₁
active₁ > tt > natsFrom₁ > mark₁
active₁ > U11₃ > splitAt₂ > mark₁
active₁ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > natsFrom₁ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > s₁ > mark₁
active₁ > U51₃ > mark₁
active₁ > afterNth₂ > mark₁
active₁ > U71₂ > mark₁
active₁ > pair₂ > U21₂ > mark₁
active₁ > pair₂ > U61₂ > mark₁
active₁ > nil > mark₁
active₁ > U81₄ > splitAt₂ > mark₁
active₁ > U82₂ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > U11₃ > splitAt₂ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > mark₁
proper₁ > pair₂ > U21₂ > mark₁
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U82₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > tt > fst₁ > U21₂ > mark₁
proper₁ > 0 > tt > splitAt₂ > mark₁
proper₁ > 0 > tt > natsFrom₁ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [3,1,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [3,4,1,2]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(124) Obligation:

Q DP problem:
The TRS P consists of the following rules:

NATSFROM(ok(X)) → NATSFROM(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(125) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

NATSFROM(ok(X)) → NATSFROM(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
NATSFROM(x1)  =  NATSFROM(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

NATSFROM₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

NATSFROM₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(126) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(127) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(128) TRUE

(129) Obligation:

Q DP problem:
The TRS P consists of the following rules:

CONS(ok(X1), ok(X2)) → CONS(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(130) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

CONS(mark(X1), X2) → CONS(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
CONS(x1, x2)  =  CONS(x1, x2)
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > splitAt₂ > isLNat₁ > mark₁ > CONS₂
active₁ > tt > natsFrom₁ > U41₂ > mark₁ > CONS₂
active₁ > tt > head₁ > U31₂ > mark₁ > CONS₂
active₁ > tt > head₁ > isLNat₁ > mark₁ > CONS₂
active₁ > tt > nil > mark₁ > CONS₂
active₁ > tt > U82₂ > cons₂ > U31₂ > mark₁ > CONS₂
active₁ > fst₁ > U21₂ > mark₁ > CONS₂
active₁ > fst₁ > isLNat₁ > mark₁ > CONS₂
active₁ > U11₃ > splitAt₂ > isLNat₁ > mark₁ > CONS₂
active₁ > U51₃ > mark₁ > CONS₂
active₁ > afterNth₂ > isLNat₁ > mark₁ > CONS₂
active₁ > U71₂ > nil > mark₁ > CONS₂
active₁ > pair₂ > U21₂ > mark₁ > CONS₂
active₁ > pair₂ > cons₂ > U31₂ > mark₁ > CONS₂
active₁ > pair₂ > U61₂ > mark₁ > CONS₂
active₁ > pair₂ > isLNat₁ > mark₁ > CONS₂
active₁ > U81₄ > U82₂ > cons₂ > U31₂ > mark₁ > CONS₂
active₁ > U91₂ > mark₁ > CONS₂
active₁ > and₂ > mark₁ > CONS₂
active₁ > isPLNat₁ > isLNat₁ > mark₁ > CONS₂
active₁ > take₂ > U101₃ > mark₁ > CONS₂
active₁ > take₂ > isLNat₁ > mark₁ > CONS₂
active₁ > sel₂ > mark₁ > CONS₂
0 > isLNat₁ > mark₁ > CONS₂
top > CONS₂

Status:

CONS₂: multiset
mark₁: multiset
active₁: [1]
U101₃: [1,3,2]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [1,2,3]
U21₂: [1,2]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [1,2]
natsFrom₁: multiset
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [2,1]
U61₂: [1,2]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: [1,4,2,3]
U82₂: [1,2]
U91₂: [2,1]
and₂: [2,1]
isLNat₁: multiset
isPLNat₁: multiset
take₂: [1,2]
0: multiset
sel₂: [1,2]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(131) Obligation:

Q DP problem:
The TRS P consists of the following rules:

CONS(ok(X1), ok(X2)) → CONS(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(132) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

CONS(ok(X1), ok(X2)) → CONS(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
CONS(x1, x2)  =  CONS(x1, x2)
ok(x1)  =  ok(x1)
active(x1)  =  x1
U101(x1, x2, x3)  =  x1
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1)
U11(x1, x2, x3)  =  U11(x1)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  x1
U31(x1, x2)  =  x1
U41(x1, x2)  =  x1
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  x1
pair(x1, x2)  =  pair(x1)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x2, x3)
U82(x1, x2)  =  x1
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x1
0  =  0
sel(x1, x2)  =  x1
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

CONS₂ > mark
nil > tt > splitAt₁ > U81₂ > ok₁ > mark
nil > tt > splitAt₁ > isLNat₁ > and₂ > ok₁ > mark
nil > tt > snd₁ > and₂ > ok₁ > mark
nil > tt > s₁ > U81₂ > ok₁ > mark
nil > tt > afterNth₁ > and₂ > ok₁ > mark
nil > tt > pair₁ > and₂ > ok₁ > mark
proper₁ > U11₁ > splitAt₁ > U81₂ > ok₁ > mark
proper₁ > U11₁ > splitAt₁ > isLNat₁ > and₂ > ok₁ > mark
proper₁ > U11₁ > snd₁ > and₂ > ok₁ > mark
proper₁ > U51₁ > afterNth₁ > and₂ > ok₁ > mark
proper₁ > head₁ > isLNat₁ > and₂ > ok₁ > mark
proper₁ > U61₂ > ok₁ > mark
proper₁ > isNatural₁ > tt > splitAt₁ > U81₂ > ok₁ > mark
proper₁ > isNatural₁ > tt > splitAt₁ > isLNat₁ > and₂ > ok₁ > mark
proper₁ > isNatural₁ > tt > snd₁ > and₂ > ok₁ > mark
proper₁ > isNatural₁ > tt > s₁ > U81₂ > ok₁ > mark
proper₁ > isNatural₁ > tt > afterNth₁ > and₂ > ok₁ > mark
proper₁ > isNatural₁ > tt > pair₁ > and₂ > ok₁ > mark
proper₁ > 0 > mark
top > mark

Status:

CONS₂: [2,1]
ok₁: [1]
tt: multiset
mark: []
splitAt₁: [1]
U11₁: [1]
snd₁: [1]
s₁: [1]
U51₁: [1]
head₁: [1]
afterNth₁: [1]
U61₂: [2,1]
pair₁: [1]
nil: multiset
U81₂: [2,1]
and₂: [1,2]
isNatural₁: [1]
isLNat₁: [1]
0: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(133) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(134) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(135) TRUE

(136) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U41¹(ok(X1), ok(X2)) → U41¹(X1, X2)
U41¹(mark(X1), X2) → U41¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(137) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U41¹(mark(X1), X2) → U41¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U41¹(x1, x2)  =  U41¹(x1)
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural
isLNat(x1)  =  isLNat
isPLNat(x1)  =  isPLNat
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > fst₁ > U21₂ > mark₁ > U41^1₁
active₁ > U101₃ > fst₁ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > tt > fst₁ > U21₂ > mark₁ > U41^1₁
active₁ > tt > fst₁ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > tt > snd₁ > mark₁ > U41^1₁
active₁ > tt > natsFrom₁ > mark₁ > U41^1₁
active₁ > tt > afterNth₂ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > tt > U82₂ > pair₂ > cons₂ > mark₁ > U41^1₁
active₁ > tt > U82₂ > pair₂ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > splitAt₂ > U71₂ > mark₁ > U41^1₁
active₁ > splitAt₂ > U81₄ > U82₂ > pair₂ > cons₂ > mark₁ > U41^1₁
active₁ > splitAt₂ > U81₄ > U82₂ > pair₂ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > U11₃ > snd₁ > mark₁ > U41^1₁
active₁ > U41₂ > cons₂ > mark₁ > U41^1₁
active₁ > U41₂ > natsFrom₁ > mark₁ > U41^1₁
active₁ > s₁ > U81₄ > U82₂ > pair₂ > cons₂ > mark₁ > U41^1₁
active₁ > s₁ > U81₄ > U82₂ > pair₂ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > U51₃ > afterNth₂ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > head₁ > U31₂ > mark₁ > U41^1₁
active₁ > head₁ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > U61₂ > mark₁ > U41^1₁
active₁ > nil > mark₁ > U41^1₁
active₁ > U91₂ > mark₁ > U41^1₁
active₁ > isNatural > isLNat > and₂ > mark₁ > U41^1₁
active₁ > isPLNat > isLNat > and₂ > mark₁ > U41^1₁
active₁ > tail₁ > isLNat > and₂ > mark₁ > U41^1₁
active₁ > take₂ > mark₁ > U41^1₁
active₁ > sel₂ > mark₁ > U41^1₁
proper₁ > U101₃ > fst₁ > U21₂ > mark₁ > U41^1₁
proper₁ > U101₃ > fst₁ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > tt > fst₁ > U21₂ > mark₁ > U41^1₁
proper₁ > tt > fst₁ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > tt > snd₁ > mark₁ > U41^1₁
proper₁ > tt > natsFrom₁ > mark₁ > U41^1₁
proper₁ > tt > afterNth₂ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > tt > U82₂ > pair₂ > cons₂ > mark₁ > U41^1₁
proper₁ > tt > U82₂ > pair₂ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > splitAt₂ > U71₂ > mark₁ > U41^1₁
proper₁ > splitAt₂ > U81₄ > U82₂ > pair₂ > cons₂ > mark₁ > U41^1₁
proper₁ > splitAt₂ > U81₄ > U82₂ > pair₂ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > U11₃ > snd₁ > mark₁ > U41^1₁
proper₁ > U41₂ > cons₂ > mark₁ > U41^1₁
proper₁ > U41₂ > natsFrom₁ > mark₁ > U41^1₁
proper₁ > s₁ > U81₄ > U82₂ > pair₂ > cons₂ > mark₁ > U41^1₁
proper₁ > s₁ > U81₄ > U82₂ > pair₂ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > U51₃ > afterNth₂ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > head₁ > U31₂ > mark₁ > U41^1₁
proper₁ > head₁ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > U61₂ > mark₁ > U41^1₁
proper₁ > nil > mark₁ > U41^1₁
proper₁ > U91₂ > mark₁ > U41^1₁
proper₁ > isNatural > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > isPLNat > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > tail₁ > isLNat > and₂ > mark₁ > U41^1₁
proper₁ > take₂ > mark₁ > U41^1₁
proper₁ > 0 > mark₁ > U41^1₁
proper₁ > sel₂ > mark₁ > U41^1₁
top > U41^1₁

Status:

U41^1₁: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [2,1,3]
snd₁: [1]
U21₂: [2,1]
U31₂: [2,1]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [1,2]
U61₂: [2,1]
U71₂: [2,1]
pair₂: [2,1]
nil: multiset
U81₄: [1,2,3,4]
U82₂: multiset
U91₂: [1,2]
and₂: [2,1]
isNatural: []
isLNat: []
isPLNat: []
tail₁: multiset
take₂: [1,2]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(138) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U41¹(ok(X1), ok(X2)) → U41¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(139) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U41¹(ok(X1), ok(X2)) → U41¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U41¹(x1, x2)  =  U41¹(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x1
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  x1
snd(x1)  =  snd(x1)
U21(x1, x2)  =  x2
U31(x1, x2)  =  x1
U41(x1, x2)  =  U41(x1)
cons(x1, x2)  =  cons(x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  x2
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1)
U91(x1, x2)  =  U91(x1)
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x1
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

0 > U71₂ > ok₁ > U41^1₁ > mark
0 > isLNat₁ > isNatural₁ > ok₁ > U41^1₁ > mark
0 > isLNat₁ > isNatural₁ > tt > mark
proper₁ > snd₁ > ok₁ > U41^1₁ > mark
proper₁ > U41₁ > s₁ > ok₁ > U41^1₁ > mark
proper₁ > cons₁ > U81₂ > U82₁ > ok₁ > U41^1₁ > mark
proper₁ > cons₁ > U91₁ > ok₁ > U41^1₁ > mark
proper₁ > cons₁ > isNatural₁ > ok₁ > U41^1₁ > mark
proper₁ > cons₁ > isNatural₁ > tt > mark
proper₁ > natsFrom₁ > isNatural₁ > ok₁ > U41^1₁ > mark
proper₁ > natsFrom₁ > isNatural₁ > tt > mark
proper₁ > U51₁ > head₁ > ok₁ > U41^1₁ > mark
proper₁ > U51₁ > afterNth₁ > ok₁ > U41^1₁ > mark
proper₁ > U61₂ > ok₁ > U41^1₁ > mark
proper₁ > U71₂ > ok₁ > U41^1₁ > mark
proper₁ > nil > ok₁ > U41^1₁ > mark
proper₁ > nil > tt > mark
proper₁ > and₁ > ok₁ > U41^1₁ > mark
proper₁ > isLNat₁ > isNatural₁ > ok₁ > U41^1₁ > mark
proper₁ > isLNat₁ > isNatural₁ > tt > mark
top > active₁ > snd₁ > ok₁ > U41^1₁ > mark
top > active₁ > U41₁ > s₁ > ok₁ > U41^1₁ > mark
top > active₁ > natsFrom₁ > isNatural₁ > ok₁ > U41^1₁ > mark
top > active₁ > natsFrom₁ > isNatural₁ > tt > mark
top > active₁ > U51₁ > head₁ > ok₁ > U41^1₁ > mark
top > active₁ > U51₁ > afterNth₁ > ok₁ > U41^1₁ > mark
top > active₁ > U61₂ > ok₁ > U41^1₁ > mark
top > active₁ > U71₂ > ok₁ > U41^1₁ > mark
top > active₁ > U81₂ > U82₁ > ok₁ > U41^1₁ > mark
top > active₁ > U91₁ > ok₁ > U41^1₁ > mark

Status:

U41^1₁: multiset
ok₁: [1]
active₁: [1]
tt: multiset
mark: multiset
snd₁: [1]
U41₁: [1]
cons₁: [1]
natsFrom₁: [1]
s₁: [1]
U51₁: multiset
head₁: multiset
afterNth₁: [1]
U61₂: [2,1]
U71₂: [1,2]
nil: multiset
U81₂: [1,2]
U82₁: [1]
U91₁: [1]
and₁: [1]
isNatural₁: multiset
isLNat₁: [1]
0: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(140) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(141) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(142) TRUE

(143) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U31¹(ok(X1), ok(X2)) → U31¹(X1, X2)
U31¹(mark(X1), X2) → U31¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(144) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U31¹(ok(X1), ok(X2)) → U31¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U31¹(x1, x2)  =  x2
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  x3
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x3
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

proper₁ > U101₂ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > cons₂ > U91₂ > ok₁
proper₁ > pair₂ > U21₂ > ok₁
proper₁ > pair₂ > U61₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₃ > ok₁
proper₁ > U82₂ > ok₁
proper₁ > and₁ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > take₂ > ok₁
proper₁ > 0 > tt > afterNth₁ > ok₁
proper₁ > 0 > U71₂ > ok₁
proper₁ > sel₂ > ok₁
top > active₁ > U101₂ > ok₁
top > active₁ > tt > afterNth₁ > ok₁
top > active₁ > U31₂ > ok₁
top > active₁ > cons₂ > U91₂ > ok₁
top > active₁ > U71₂ > ok₁
top > active₁ > pair₂ > U21₂ > ok₁
top > active₁ > pair₂ > U61₂ > ok₁
top > active₁ > nil > ok₁
top > active₁ > U81₃ > ok₁
top > active₁ > U82₂ > ok₁
top > active₁ > and₁ > ok₁
top > active₁ > isNatural₁ > ok₁
top > active₁ > take₂ > ok₁
top > active₁ > sel₂ > ok₁

Status:

ok₁: [1]
active₁: multiset
U101₂: [2,1]
tt: multiset
U21₂: [2,1]
U31₂: [1,2]
cons₂: [2,1]
afterNth₁: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: [2,1]
nil: multiset
U81₃: [1,2,3]
U82₂: [1,2]
U91₂: [1,2]
and₁: multiset
isNatural₁: multiset
take₂: [2,1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(145) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U31¹(mark(X1), X2) → U31¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(146) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U31¹(mark(X1), X2) → U31¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U31¹(x1, x2)  =  U31¹(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U31^1₂ > ok
active₁ > snd₁ > and₂ > mark₁ > ok
active₁ > U21₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > cons₂ > U31₂ > mark₁ > ok
active₁ > cons₂ > U81₄ > mark₁ > ok
active₁ > cons₂ > U91₂ > mark₁ > ok
active₁ > head₁ > U31₂ > mark₁ > ok
active₁ > head₁ > and₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > U71₂ > pair₂ > mark₁ > ok
active₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
active₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > nil > tt > pair₂ > mark₁ > ok
active₁ > nil > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
active₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > and₂ > mark₁ > ok
active₁ > isPLNat₁ > and₂ > mark₁ > ok
active₁ > tail₁ > U91₂ > mark₁ > ok
active₁ > tail₁ > and₂ > mark₁ > ok
active₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > sel₂ > U51₃ > mark₁ > ok
0 > tt > s₁ > U81₄ > mark₁ > ok
0 > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
0 > tt > pair₂ > mark₁ > ok
0 > tt > U82₂ > mark₁ > ok
0 > U71₂ > pair₂ > mark₁ > ok
proper₁ > snd₁ > and₂ > mark₁ > ok
proper₁ > U21₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > cons₂ > U31₂ > mark₁ > ok
proper₁ > cons₂ > U81₄ > mark₁ > ok
proper₁ > cons₂ > U91₂ > mark₁ > ok
proper₁ > head₁ > U31₂ > mark₁ > ok
proper₁ > head₁ > and₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > U71₂ > pair₂ > mark₁ > ok
proper₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > nil > tt > pair₂ > mark₁ > ok
proper₁ > nil > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > and₂ > mark₁ > ok
proper₁ > isPLNat₁ > and₂ > mark₁ > ok
proper₁ > tail₁ > U91₂ > mark₁ > ok
proper₁ > tail₁ > and₂ > mark₁ > ok
proper₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > sel₂ > U51₃ > mark₁ > ok
top > ok

Status:

U31^1₂: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,3,2]
tt: multiset
splitAt₂: [2,1]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
s₁: multiset
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: multiset
U91₂: [2,1]
and₂: [2,1]
isNatural₁: multiset
isPLNat₁: multiset
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(147) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(148) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(149) TRUE

(150) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U21¹(ok(X1), ok(X2)) → U21¹(X1, X2)
U21¹(mark(X1), X2) → U21¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(151) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U21¹(ok(X1), ok(X2)) → U21¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U21¹(x1, x2)  =  U21¹(x1)
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  U11(x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₁ > ok₁
active₁ > tt > fst₁ > ok₁
active₁ > tt > snd₁ > ok₁
active₁ > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
active₁ > tt > head₁ > ok₁
active₁ > tt > U82₂ > cons₂ > ok₁
active₁ > U11₁ > snd₁ > ok₁
active₁ > U31₂ > ok₁
active₁ > afterNth₂ > ok₁
active₁ > U71₂ > ok₁
active₁ > pair₂ > U21₂ > ok₁
active₁ > pair₂ > cons₂ > ok₁
active₁ > nil > ok₁
active₁ > U81₂ > U82₂ > cons₂ > ok₁
active₁ > and₁ > ok₁
active₁ > isNatural₁ > ok₁
active₁ > isLNat₁ > ok₁
active₁ > tail₁ > ok₁
active₁ > sel₂ > U51₃ > head₁ > ok₁
0 > tt > fst₁ > ok₁
0 > tt > snd₁ > ok₁
0 > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
0 > tt > head₁ > ok₁
0 > tt > U82₂ > cons₂ > ok₁
0 > U71₂ > ok₁
0 > isLNat₁ > ok₁
proper₁ > U101₁ > ok₁
proper₁ > tt > fst₁ > ok₁
proper₁ > tt > snd₁ > ok₁
proper₁ > tt > natsFrom₁ > U41₂ > cons₂ > ok₁
proper₁ > tt > head₁ > ok₁
proper₁ > tt > U82₂ > cons₂ > ok₁
proper₁ > U11₁ > snd₁ > ok₁
proper₁ > U31₂ > ok₁
proper₁ > afterNth₂ > ok₁
proper₁ > U71₂ > ok₁
proper₁ > pair₂ > U21₂ > ok₁
proper₁ > pair₂ > cons₂ > ok₁
proper₁ > nil > ok₁
proper₁ > U81₂ > U82₂ > cons₂ > ok₁
proper₁ > and₁ > ok₁
proper₁ > isNatural₁ > ok₁
proper₁ > isLNat₁ > ok₁
proper₁ > tail₁ > ok₁
proper₁ > sel₂ > U51₃ > head₁ > ok₁

Status:

U21^1₁: multiset
ok₁: [1]
active₁: [1]
U101₁: [1]
tt: multiset
fst₁: [1]
U11₁: [1]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
U51₃: [1,2,3]
head₁: [1]
afterNth₂: [2,1]
U71₂: [2,1]
pair₂: [2,1]
nil: multiset
U81₂: [1,2]
U82₂: [1,2]
and₁: [1]
isNatural₁: [1]
isLNat₁: [1]
tail₁: [1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(152) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U21¹(mark(X1), X2) → U21¹(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(153) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U21¹(mark(X1), X2) → U21¹(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U21¹(x1, x2)  =  U21¹(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

U21^1₁ > ok
active₁ > U101₃ > splitAt₂ > U71₂ > mark₁ > ok
active₁ > tt > snd₁ > isPLNat₁ > mark₁ > ok
active₁ > tt > cons₂ > U31₂ > mark₁ > ok
active₁ > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > mark₁ > ok
active₁ > tt > cons₂ > U91₂ > mark₁ > ok
active₁ > tt > afterNth₂ > U11₃ > mark₁ > ok
active₁ > tt > pair₂ > U21₂ > mark₁ > ok
active₁ > tt > nil > mark₁ > ok
active₁ > tt > U82₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > and₂ > mark₁ > ok
active₁ > take₂ > mark₁ > ok
active₁ > sel₂ > U51₃ > afterNth₂ > U11₃ > mark₁ > ok
proper₁ > U101₃ > splitAt₂ > U71₂ > mark₁ > ok
proper₁ > tt > snd₁ > isPLNat₁ > mark₁ > ok
proper₁ > tt > cons₂ > U31₂ > mark₁ > ok
proper₁ > tt > cons₂ > U81₄ > splitAt₂ > U71₂ > mark₁ > ok
proper₁ > tt > cons₂ > U91₂ > mark₁ > ok
proper₁ > tt > afterNth₂ > U11₃ > mark₁ > ok
proper₁ > tt > pair₂ > U21₂ > mark₁ > ok
proper₁ > tt > nil > mark₁ > ok
proper₁ > tt > U82₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > and₂ > mark₁ > ok
proper₁ > take₂ > mark₁ > ok
proper₁ > 0 > mark₁ > ok
proper₁ > sel₂ > U51₃ > afterNth₂ > U11₃ > mark₁ > ok
top > ok

Status:

U21^1₁: [1]
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [2,1]
U51₃: multiset
afterNth₂: [2,1]
U61₂: [2,1]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: [2,1]
U91₂: [2,1]
and₂: [2,1]
isPLNat₁: multiset
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(154) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(155) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(156) TRUE

(157) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SND(ok(X)) → SND(X)
SND(mark(X)) → SND(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(158) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SND(mark(X)) → SND(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SND(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > splitAt₂ > mark₁
active₁ > tt > natsFrom₁ > mark₁
active₁ > U11₃ > splitAt₂ > mark₁
active₁ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > natsFrom₁ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > s₁ > mark₁
active₁ > U51₃ > mark₁
active₁ > afterNth₂ > mark₁
active₁ > U71₂ > mark₁
active₁ > pair₂ > U21₂ > mark₁
active₁ > pair₂ > U61₂ > mark₁
active₁ > nil > mark₁
active₁ > U81₄ > splitAt₂ > mark₁
active₁ > U82₂ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > U11₃ > splitAt₂ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > mark₁
proper₁ > pair₂ > U21₂ > mark₁
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U82₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > tt > fst₁ > U21₂ > mark₁
proper₁ > 0 > tt > splitAt₂ > mark₁
proper₁ > 0 > tt > natsFrom₁ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [3,1,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [3,4,1,2]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(159) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SND(ok(X)) → SND(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(160) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SND(ok(X)) → SND(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SND(x1)  =  SND(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

SND₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

SND₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(161) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(162) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(163) TRUE

(164) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U11¹(ok(X1), ok(X2), ok(X3)) → U11¹(X1, X2, X3)
U11¹(mark(X1), X2, X3) → U11¹(X1, X2, X3)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(165) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U11¹(ok(X1), ok(X2), ok(X3)) → U11¹(X1, X2, X3)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U11¹(x1, x2, x3)  =  U11¹(x3)
ok(x1)  =  ok(x1)
mark(x1)  =  x1
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  x2
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > splitAt₂ > U81₄ > ok₁ > U11^1₁
active₁ > splitAt₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > splitAt₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > U11₃ > ok₁ > U11^1₁
active₁ > snd₁ > isPLNat₁ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > snd₁ > isPLNat₁ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > U21₁ > ok₁ > U11^1₁
active₁ > U31₂ > ok₁ > U11^1₁
active₁ > natsFrom₁ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > natsFrom₁ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > afterNth₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > afterNth₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > U61₂ > ok₁ > U11^1₁
active₁ > nil > ok₁ > U11^1₁
active₁ > nil > tt > U11^1₁
active₁ > U82₂ > cons₂ > U81₄ > ok₁ > U11^1₁
active₁ > U82₂ > cons₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > U82₂ > cons₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > U82₂ > pair₂ > isLNat₁ > ok₁ > U11^1₁
active₁ > U82₂ > pair₂ > isLNat₁ > tt > U11^1₁
active₁ > and₁ > ok₁ > U11^1₁
active₁ > tail₁ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > tail₁ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > take₂ > U101₃ > ok₁ > U11^1₁
active₁ > take₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > take₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
active₁ > sel₂ > U51₃ > ok₁ > U11^1₁
active₁ > sel₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
active₁ > sel₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > splitAt₂ > U81₄ > ok₁ > U11^1₁
proper₁ > splitAt₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > splitAt₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > U11₃ > ok₁ > U11^1₁
proper₁ > snd₁ > isPLNat₁ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > snd₁ > isPLNat₁ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > U21₁ > ok₁ > U11^1₁
proper₁ > U31₂ > ok₁ > U11^1₁
proper₁ > natsFrom₁ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > natsFrom₁ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > afterNth₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > afterNth₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > U61₂ > ok₁ > U11^1₁
proper₁ > nil > ok₁ > U11^1₁
proper₁ > nil > tt > U11^1₁
proper₁ > U82₂ > cons₂ > U81₄ > ok₁ > U11^1₁
proper₁ > U82₂ > cons₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > U82₂ > cons₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > U82₂ > pair₂ > isLNat₁ > ok₁ > U11^1₁
proper₁ > U82₂ > pair₂ > isLNat₁ > tt > U11^1₁
proper₁ > and₁ > ok₁ > U11^1₁
proper₁ > tail₁ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > tail₁ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > take₂ > U101₃ > ok₁ > U11^1₁
proper₁ > take₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > take₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
proper₁ > 0 > isLNat₁ > ok₁ > U11^1₁
proper₁ > 0 > isLNat₁ > tt > U11^1₁
proper₁ > sel₂ > U51₃ > ok₁ > U11^1₁
proper₁ > sel₂ > isNatural₁ > isLNat₁ > ok₁ > U11^1₁
proper₁ > sel₂ > isNatural₁ > isLNat₁ > tt > U11^1₁
top > U11^1₁

Status:

U11^1₁: multiset
ok₁: [1]
active₁: [1]
U101₃: [3,1,2]
tt: multiset
splitAt₂: [1,2]
U11₃: [2,1,3]
snd₁: [1]
U21₁: multiset
U31₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
U51₃: [1,3,2]
afterNth₂: [2,1]
U61₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: [2,3,1,4]
U82₂: [2,1]
and₁: [1]
isNatural₁: [1]
isLNat₁: multiset
isPLNat₁: [1]
tail₁: [1]
take₂: [2,1]
0: multiset
sel₂: [2,1]
proper₁: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(166) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U11¹(mark(X1), X2, X3) → U11¹(X1, X2, X3)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(167) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U11¹(mark(X1), X2, X3) → U11¹(X1, X2, X3)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U11¹(x1, x2, x3)  =  U11¹(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural
isLNat(x1)  =  isLNat
isPLNat(x1)  =  isPLNat
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > snd₁ > and₂ > mark₁
active₁ > snd₁ > and₂ > ok
active₁ > U21₂ > mark₁
active₁ > U21₂ > ok
active₁ > U31₂ > mark₁
active₁ > U31₂ > ok
active₁ > U41₂ > cons₂ > and₂ > mark₁
active₁ > U41₂ > cons₂ > and₂ > ok
active₁ > s₁ > U81₄ > splitAt₂ > mark₁
active₁ > s₁ > U81₄ > splitAt₂ > ok
active₁ > s₁ > U81₄ > U82₂ > mark₁
active₁ > s₁ > U81₄ > U82₂ > ok
active₁ > s₁ > isLNat > tt > mark₁
active₁ > s₁ > isLNat > tt > ok
active₁ > s₁ > isLNat > and₂ > mark₁
active₁ > s₁ > isLNat > and₂ > ok
active₁ > head₁ > isLNat > tt > mark₁
active₁ > head₁ > isLNat > tt > ok
active₁ > head₁ > isLNat > and₂ > mark₁
active₁ > head₁ > isLNat > and₂ > ok
active₁ > afterNth₂ > U11₃ > mark₁
active₁ > afterNth₂ > U11₃ > ok
active₁ > afterNth₂ > isLNat > tt > mark₁
active₁ > afterNth₂ > isLNat > tt > ok
active₁ > afterNth₂ > isLNat > and₂ > mark₁
active₁ > afterNth₂ > isLNat > and₂ > ok
active₁ > U71₂ > nil > tt > mark₁
active₁ > U71₂ > nil > tt > ok
active₁ > pair₂ > cons₂ > and₂ > mark₁
active₁ > pair₂ > cons₂ > and₂ > ok
active₁ > pair₂ > U61₂ > mark₁
active₁ > pair₂ > U61₂ > ok
active₁ > pair₂ > isLNat > tt > mark₁
active₁ > pair₂ > isLNat > tt > ok
active₁ > pair₂ > isLNat > and₂ > mark₁
active₁ > pair₂ > isLNat > and₂ > ok
active₁ > U91₂ > mark₁
active₁ > U91₂ > ok
active₁ > isNatural > isLNat > tt > mark₁
active₁ > isNatural > isLNat > tt > ok
active₁ > isNatural > isLNat > and₂ > mark₁
active₁ > isNatural > isLNat > and₂ > ok
active₁ > isPLNat > isLNat > tt > mark₁
active₁ > isPLNat > isLNat > tt > ok
active₁ > isPLNat > isLNat > and₂ > mark₁
active₁ > isPLNat > isLNat > and₂ > ok
active₁ > tail₁ > mark₁
active₁ > tail₁ > ok
active₁ > take₂ > U101₃ > fst₁ > mark₁
active₁ > take₂ > U101₃ > fst₁ > ok
active₁ > take₂ > U101₃ > splitAt₂ > mark₁
active₁ > take₂ > U101₃ > splitAt₂ > ok
active₁ > take₂ > isLNat > tt > mark₁
active₁ > take₂ > isLNat > tt > ok
active₁ > take₂ > isLNat > and₂ > mark₁
active₁ > take₂ > isLNat > and₂ > ok
active₁ > sel₂ > U51₃ > mark₁
active₁ > sel₂ > U51₃ > ok
active₁ > sel₂ > isLNat > tt > mark₁
active₁ > sel₂ > isLNat > tt > ok
active₁ > sel₂ > isLNat > and₂ > mark₁
active₁ > sel₂ > isLNat > and₂ > ok
proper₁ > snd₁ > and₂ > mark₁
proper₁ > snd₁ > and₂ > ok
proper₁ > U21₂ > mark₁
proper₁ > U21₂ > ok
proper₁ > U31₂ > mark₁
proper₁ > U31₂ > ok
proper₁ > U41₂ > cons₂ > and₂ > mark₁
proper₁ > U41₂ > cons₂ > and₂ > ok
proper₁ > s₁ > U81₄ > splitAt₂ > mark₁
proper₁ > s₁ > U81₄ > splitAt₂ > ok
proper₁ > s₁ > U81₄ > U82₂ > mark₁
proper₁ > s₁ > U81₄ > U82₂ > ok
proper₁ > s₁ > isLNat > tt > mark₁
proper₁ > s₁ > isLNat > tt > ok
proper₁ > s₁ > isLNat > and₂ > mark₁
proper₁ > s₁ > isLNat > and₂ > ok
proper₁ > head₁ > isLNat > tt > mark₁
proper₁ > head₁ > isLNat > tt > ok
proper₁ > head₁ > isLNat > and₂ > mark₁
proper₁ > head₁ > isLNat > and₂ > ok
proper₁ > afterNth₂ > U11₃ > mark₁
proper₁ > afterNth₂ > U11₃ > ok
proper₁ > afterNth₂ > isLNat > tt > mark₁
proper₁ > afterNth₂ > isLNat > tt > ok
proper₁ > afterNth₂ > isLNat > and₂ > mark₁
proper₁ > afterNth₂ > isLNat > and₂ > ok
proper₁ > U71₂ > nil > tt > mark₁
proper₁ > U71₂ > nil > tt > ok
proper₁ > pair₂ > cons₂ > and₂ > mark₁
proper₁ > pair₂ > cons₂ > and₂ > ok
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > pair₂ > U61₂ > ok
proper₁ > pair₂ > isLNat > tt > mark₁
proper₁ > pair₂ > isLNat > tt > ok
proper₁ > pair₂ > isLNat > and₂ > mark₁
proper₁ > pair₂ > isLNat > and₂ > ok
proper₁ > U91₂ > mark₁
proper₁ > U91₂ > ok
proper₁ > isNatural > isLNat > tt > mark₁
proper₁ > isNatural > isLNat > tt > ok
proper₁ > isNatural > isLNat > and₂ > mark₁
proper₁ > isNatural > isLNat > and₂ > ok
proper₁ > isPLNat > isLNat > tt > mark₁
proper₁ > isPLNat > isLNat > tt > ok
proper₁ > isPLNat > isLNat > and₂ > mark₁
proper₁ > isPLNat > isLNat > and₂ > ok
proper₁ > tail₁ > mark₁
proper₁ > tail₁ > ok
proper₁ > take₂ > U101₃ > fst₁ > mark₁
proper₁ > take₂ > U101₃ > fst₁ > ok
proper₁ > take₂ > U101₃ > splitAt₂ > mark₁
proper₁ > take₂ > U101₃ > splitAt₂ > ok
proper₁ > take₂ > isLNat > tt > mark₁
proper₁ > take₂ > isLNat > tt > ok
proper₁ > take₂ > isLNat > and₂ > mark₁
proper₁ > take₂ > isLNat > and₂ > ok
proper₁ > 0 > tt > mark₁
proper₁ > 0 > tt > ok
proper₁ > sel₂ > U51₃ > mark₁
proper₁ > sel₂ > U51₃ > ok
proper₁ > sel₂ > isLNat > tt > mark₁
proper₁ > sel₂ > isLNat > tt > ok
proper₁ > sel₂ > isLNat > and₂ > mark₁
proper₁ > sel₂ > isLNat > and₂ > ok

Status:

U11^1₁: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [1,2,3]
snd₁: multiset
U21₂: [1,2]
U31₂: [1,2]
U41₂: [1,2]
cons₂: multiset
s₁: [1]
U51₃: [1,3,2]
head₁: multiset
afterNth₂: [1,2]
U61₂: [2,1]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [4,2,1,3]
U82₂: [2,1]
U91₂: [2,1]
and₂: [1,2]
isNatural: []
isLNat: []
isPLNat: []
tail₁: multiset
take₂: multiset
0: multiset
sel₂: [1,2]
proper₁: [1]
ok: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(168) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(169) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(170) TRUE

(171) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SPLITAT(X1, mark(X2)) → SPLITAT(X1, X2)
SPLITAT(mark(X1), X2) → SPLITAT(X1, X2)
SPLITAT(ok(X1), ok(X2)) → SPLITAT(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(172) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SPLITAT(ok(X1), ok(X2)) → SPLITAT(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SPLITAT(x1, x2)  =  SPLITAT(x1, x2)
mark(x1)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  x2
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  x2
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

proper₁ > fst₁ > U21₁ > ok₁ > SPLITAT₂
proper₁ > snd₁ > isLNat₁ > ok₁ > SPLITAT₂
proper₁ > snd₁ > isLNat₁ > tt
proper₁ > U31₂ > ok₁ > SPLITAT₂
proper₁ > U51₃ > head₁ > ok₁ > SPLITAT₂
proper₁ > afterNth₂ > U11₃ > ok₁ > SPLITAT₂
proper₁ > pair₂ > U21₁ > ok₁ > SPLITAT₂
proper₁ > pair₂ > cons₂ > ok₁ > SPLITAT₂
proper₁ > pair₂ > isLNat₁ > ok₁ > SPLITAT₂
proper₁ > pair₂ > isLNat₁ > tt
proper₁ > nil > ok₁ > SPLITAT₂
proper₁ > nil > tt
proper₁ > U81₂ > ok₁ > SPLITAT₂
proper₁ > U82₂ > cons₂ > ok₁ > SPLITAT₂
proper₁ > U91₂ > ok₁ > SPLITAT₂
proper₁ > isPLNat₁ > isLNat₁ > ok₁ > SPLITAT₂
proper₁ > isPLNat₁ > isLNat₁ > tt
proper₁ > take₂ > ok₁ > SPLITAT₂
proper₁ > 0 > U71₂ > ok₁ > SPLITAT₂
proper₁ > 0 > isLNat₁ > ok₁ > SPLITAT₂
proper₁ > 0 > isLNat₁ > tt
proper₁ > sel₂ > ok₁ > SPLITAT₂
top > active₁ > fst₁ > U21₁ > ok₁ > SPLITAT₂
top > active₁ > snd₁ > isLNat₁ > ok₁ > SPLITAT₂
top > active₁ > snd₁ > isLNat₁ > tt
top > active₁ > U31₂ > ok₁ > SPLITAT₂
top > active₁ > U51₃ > head₁ > ok₁ > SPLITAT₂
top > active₁ > afterNth₂ > U11₃ > ok₁ > SPLITAT₂
top > active₁ > U71₂ > ok₁ > SPLITAT₂
top > active₁ > pair₂ > U21₁ > ok₁ > SPLITAT₂
top > active₁ > pair₂ > cons₂ > ok₁ > SPLITAT₂
top > active₁ > pair₂ > isLNat₁ > ok₁ > SPLITAT₂
top > active₁ > pair₂ > isLNat₁ > tt
top > active₁ > nil > ok₁ > SPLITAT₂
top > active₁ > nil > tt
top > active₁ > U81₂ > ok₁ > SPLITAT₂
top > active₁ > U82₂ > cons₂ > ok₁ > SPLITAT₂
top > active₁ > U91₂ > ok₁ > SPLITAT₂
top > active₁ > isPLNat₁ > isLNat₁ > ok₁ > SPLITAT₂
top > active₁ > isPLNat₁ > isLNat₁ > tt
top > active₁ > take₂ > ok₁ > SPLITAT₂
top > active₁ > sel₂ > ok₁ > SPLITAT₂

Status:

SPLITAT₂: multiset
ok₁: [1]
active₁: [1]
tt: multiset
fst₁: [1]
U11₃: [3,1,2]
snd₁: [1]
U21₁: [1]
U31₂: [2,1]
cons₂: [2,1]
U51₃: [3,1,2]
head₁: [1]
afterNth₂: [2,1]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₂: [1,2]
U82₂: [2,1]
U91₂: [2,1]
isLNat₁: [1]
isPLNat₁: [1]
take₂: [1,2]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(173) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SPLITAT(X1, mark(X2)) → SPLITAT(X1, X2)
SPLITAT(mark(X1), X2) → SPLITAT(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(174) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SPLITAT(X1, mark(X2)) → SPLITAT(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SPLITAT(x1, x2)  =  SPLITAT(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > splitAt₂ > U71₂ > mark₁
active₁ > U101₃ > splitAt₂ > and₂ > mark₁
active₁ > tt > splitAt₂ > U71₂ > mark₁
active₁ > tt > splitAt₂ > and₂ > mark₁
active₁ > tt > cons₂ > U31₂ > mark₁
active₁ > tt > pair₂ > mark₁
active₁ > tt > nil > mark₁
active₁ > U11₃ > splitAt₂ > U71₂ > mark₁
active₁ > U11₃ > splitAt₂ > and₂ > mark₁
active₁ > U21₂ > mark₁
active₁ > U41₂ > mark₁
active₁ > U51₃ > mark₁
active₁ > head₁ > U31₂ > mark₁
active₁ > head₁ > isNatural₁ > and₂ > mark₁
active₁ > afterNth₂ > isNatural₁ > and₂ > mark₁
active₁ > U61₂ > mark₁
active₁ > U81₄ > splitAt₂ > U71₂ > mark₁
active₁ > U81₄ > splitAt₂ > and₂ > mark₁
active₁ > U82₂ > cons₂ > U31₂ > mark₁
active₁ > U82₂ > pair₂ > mark₁
active₁ > isPLNat₁ > isNatural₁ > and₂ > mark₁
active₁ > tail₁ > U91₂ > mark₁
active₁ > tail₁ > isNatural₁ > and₂ > mark₁
active₁ > take₂ > mark₁
active₁ > sel₂ > isNatural₁ > and₂ > mark₁
proper₁ > U101₃ > splitAt₂ > U71₂ > mark₁
proper₁ > U101₃ > splitAt₂ > and₂ > mark₁
proper₁ > tt > splitAt₂ > U71₂ > mark₁
proper₁ > tt > splitAt₂ > and₂ > mark₁
proper₁ > tt > cons₂ > U31₂ > mark₁
proper₁ > tt > pair₂ > mark₁
proper₁ > tt > nil > mark₁
proper₁ > U11₃ > splitAt₂ > U71₂ > mark₁
proper₁ > U11₃ > splitAt₂ > and₂ > mark₁
proper₁ > U21₂ > mark₁
proper₁ > U41₂ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > head₁ > U31₂ > mark₁
proper₁ > head₁ > isNatural₁ > and₂ > mark₁
proper₁ > afterNth₂ > isNatural₁ > and₂ > mark₁
proper₁ > U61₂ > mark₁
proper₁ > U81₄ > splitAt₂ > U71₂ > mark₁
proper₁ > U81₄ > splitAt₂ > and₂ > mark₁
proper₁ > U82₂ > cons₂ > U31₂ > mark₁
proper₁ > U82₂ > pair₂ > mark₁
proper₁ > isPLNat₁ > isNatural₁ > and₂ > mark₁
proper₁ > tail₁ > U91₂ > mark₁
proper₁ > tail₁ > isNatural₁ > and₂ > mark₁
proper₁ > take₂ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > isNatural₁ > and₂ > mark₁

Status:

SPLITAT₁: [1]
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,3,2]
U21₂: [2,1]
U31₂: multiset
U41₂: [2,1]
cons₂: [1,2]
U51₃: [3,2,1]
head₁: [1]
afterNth₂: [1,2]
U61₂: [2,1]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [1,3,4,2]
U82₂: multiset
U91₂: [2,1]
and₂: [1,2]
isNatural₁: multiset
isPLNat₁: [1]
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(175) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SPLITAT(mark(X1), X2) → SPLITAT(X1, X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(176) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

SPLITAT(mark(X1), X2) → SPLITAT(X1, X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
SPLITAT(x1, x2)  =  SPLITAT(x1, x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

SPLITAT₂ > ok
active₁ > snd₁ > and₂ > mark₁ > ok
active₁ > U21₂ > mark₁ > ok
active₁ > U41₂ > mark₁ > ok
active₁ > cons₂ > U31₂ > mark₁ > ok
active₁ > cons₂ > U81₄ > mark₁ > ok
active₁ > cons₂ > U91₂ > mark₁ > ok
active₁ > head₁ > U31₂ > mark₁ > ok
active₁ > head₁ > and₂ > mark₁ > ok
active₁ > U61₂ > mark₁ > ok
active₁ > U71₂ > pair₂ > mark₁ > ok
active₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
active₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > nil > tt > pair₂ > mark₁ > ok
active₁ > nil > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
active₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
active₁ > isNatural₁ > and₂ > mark₁ > ok
active₁ > isPLNat₁ > and₂ > mark₁ > ok
active₁ > tail₁ > U91₂ > mark₁ > ok
active₁ > tail₁ > and₂ > mark₁ > ok
active₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
active₁ > sel₂ > U51₃ > mark₁ > ok
0 > tt > s₁ > U81₄ > mark₁ > ok
0 > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
0 > tt > pair₂ > mark₁ > ok
0 > tt > U82₂ > mark₁ > ok
0 > U71₂ > pair₂ > mark₁ > ok
proper₁ > snd₁ > and₂ > mark₁ > ok
proper₁ > U21₂ > mark₁ > ok
proper₁ > U41₂ > mark₁ > ok
proper₁ > cons₂ > U31₂ > mark₁ > ok
proper₁ > cons₂ > U81₄ > mark₁ > ok
proper₁ > cons₂ > U91₂ > mark₁ > ok
proper₁ > head₁ > U31₂ > mark₁ > ok
proper₁ > head₁ > and₂ > mark₁ > ok
proper₁ > U61₂ > mark₁ > ok
proper₁ > U71₂ > pair₂ > mark₁ > ok
proper₁ > nil > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > nil > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > nil > tt > pair₂ > mark₁ > ok
proper₁ > nil > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > s₁ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > afterNth₂ > U11₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > isNatural₁ > tt > pair₂ > mark₁ > ok
proper₁ > isNatural₁ > tt > U82₂ > mark₁ > ok
proper₁ > isNatural₁ > and₂ > mark₁ > ok
proper₁ > isPLNat₁ > and₂ > mark₁ > ok
proper₁ > tail₁ > U91₂ > mark₁ > ok
proper₁ > tail₁ > and₂ > mark₁ > ok
proper₁ > take₂ > U101₃ > splitAt₂ > U81₄ > mark₁ > ok
proper₁ > sel₂ > U51₃ > mark₁ > ok
top > ok

Status:

SPLITAT₂: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,3,2]
tt: multiset
splitAt₂: [2,1]
U11₃: [1,3,2]
snd₁: multiset
U21₂: [2,1]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
s₁: multiset
U51₃: [1,2,3]
head₁: multiset
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [2,1]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: multiset
U91₂: [2,1]
and₂: [2,1]
isNatural₁: multiset
isPLNat₁: multiset
tail₁: [1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(177) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(178) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(179) TRUE

(180) Obligation:

Q DP problem:
The TRS P consists of the following rules:

FST(ok(X)) → FST(X)
FST(mark(X)) → FST(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(181) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

FST(mark(X)) → FST(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FST(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > tt > fst₁ > U21₂ > mark₁
active₁ > tt > splitAt₂ > mark₁
active₁ > tt > natsFrom₁ > mark₁
active₁ > U11₃ > splitAt₂ > mark₁
active₁ > snd₁ > U61₂ > mark₁
active₁ > U41₂ > natsFrom₁ > mark₁
active₁ > cons₂ > U31₂ > mark₁
active₁ > s₁ > mark₁
active₁ > U51₃ > mark₁
active₁ > afterNth₂ > mark₁
active₁ > U71₂ > mark₁
active₁ > pair₂ > U21₂ > mark₁
active₁ > pair₂ > U61₂ > mark₁
active₁ > nil > mark₁
active₁ > U81₄ > splitAt₂ > mark₁
active₁ > U82₂ > mark₁
active₁ > U91₂ > mark₁
active₁ > and₂ > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > sel₂ > mark₁
proper₁ > U11₃ > splitAt₂ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > cons₂ > U31₂ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > mark₁
proper₁ > pair₂ > U21₂ > mark₁
proper₁ > pair₂ > U61₂ > mark₁
proper₁ > nil > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U82₂ > mark₁
proper₁ > U91₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > 0 > tt > fst₁ > U21₂ > mark₁
proper₁ > 0 > tt > splitAt₂ > mark₁
proper₁ > 0 > tt > natsFrom₁ > mark₁
proper₁ > 0 > U71₂ > mark₁
proper₁ > sel₂ > mark₁

Status:

mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
fst₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [1,2]
U41₂: [1,2]
cons₂: [2,1]
natsFrom₁: [1]
s₁: [1]
U51₃: [3,1,2]
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: multiset
nil: multiset
U81₄: [3,4,1,2]
U82₂: [1,2]
U91₂: [1,2]
and₂: [2,1]
take₂: multiset
0: multiset
sel₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(182) Obligation:

Q DP problem:
The TRS P consists of the following rules:

FST(ok(X)) → FST(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(183) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

FST(ok(X)) → FST(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
FST(x1)  =  FST(x1)
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  x3
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  x2
U31(x1, x2)  =  x2
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  x2
head(x1)  =  x1
afterNth(x1, x2)  =  x2
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  x1
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x2
U91(x1, x2)  =  x1
and(x1, x2)  =  x2
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x2
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

FST₁ > mark
active₁ > tt > ok₁ > mark
proper > nil > tt > ok₁ > mark
proper > 0 > mark
top > mark

Status:

FST₁: multiset
ok₁: [1]
active₁: multiset
tt: multiset
mark: multiset
nil: multiset
0: multiset
proper: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(184) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(185) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(186) TRUE

(187) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U101¹(ok(X1), ok(X2), ok(X3)) → U101¹(X1, X2, X3)
U101¹(mark(X1), X2, X3) → U101¹(X1, X2, X3)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(188) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U101¹(mark(X1), X2, X3) → U101¹(X1, X2, X3)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U101¹(x1, x2, x3)  =  U101¹(x1)
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  x1
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural
isLNat(x1)  =  isLNat
isPLNat(x1)  =  isPLNat
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U101₃ > mark₁ > U101^1₁ > isPLNat
active₁ > tt > nil > mark₁ > U101^1₁ > isPLNat
active₁ > tt > U82₂ > pair₂ > mark₁ > U101^1₁ > isPLNat
active₁ > tt > U82₂ > pair₂ > isLNat > isPLNat
active₁ > splitAt₂ > U71₂ > mark₁ > U101^1₁ > isPLNat
active₁ > splitAt₂ > U81₄ > mark₁ > U101^1₁ > isPLNat
active₁ > splitAt₂ > isNatural > isLNat > isPLNat
active₁ > U21₂ > mark₁ > U101^1₁ > isPLNat
active₁ > U41₂ > mark₁ > U101^1₁ > isPLNat
active₁ > cons₂ > U31₂ > mark₁ > U101^1₁ > isPLNat
active₁ > cons₂ > U81₄ > mark₁ > U101^1₁ > isPLNat
active₁ > cons₂ > U91₂ > mark₁ > U101^1₁ > isPLNat
active₁ > cons₂ > isNatural > isLNat > isPLNat
active₁ > U51₃ > mark₁ > U101^1₁ > isPLNat
active₁ > afterNth₂ > U11₃ > mark₁ > U101^1₁ > isPLNat
active₁ > afterNth₂ > isNatural > isLNat > isPLNat
active₁ > U61₂ > mark₁ > U101^1₁ > isPLNat
active₁ > and₂ > mark₁ > U101^1₁ > isPLNat
active₁ > take₂ > mark₁ > U101^1₁ > isPLNat
active₁ > take₂ > isNatural > isLNat > isPLNat
active₁ > sel₂ > mark₁ > U101^1₁ > isPLNat
active₁ > sel₂ > isNatural > isLNat > isPLNat
0 > tt > nil > mark₁ > U101^1₁ > isPLNat
0 > tt > U82₂ > pair₂ > mark₁ > U101^1₁ > isPLNat
0 > tt > U82₂ > pair₂ > isLNat > isPLNat
0 > U71₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > U101₃ > mark₁ > U101^1₁ > isPLNat
proper₁ > tt > nil > mark₁ > U101^1₁ > isPLNat
proper₁ > tt > U82₂ > pair₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > tt > U82₂ > pair₂ > isLNat > isPLNat
proper₁ > splitAt₂ > U71₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > splitAt₂ > U81₄ > mark₁ > U101^1₁ > isPLNat
proper₁ > splitAt₂ > isNatural > isLNat > isPLNat
proper₁ > U21₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > U41₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > cons₂ > U31₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > cons₂ > U81₄ > mark₁ > U101^1₁ > isPLNat
proper₁ > cons₂ > U91₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > cons₂ > isNatural > isLNat > isPLNat
proper₁ > U51₃ > mark₁ > U101^1₁ > isPLNat
proper₁ > afterNth₂ > U11₃ > mark₁ > U101^1₁ > isPLNat
proper₁ > afterNth₂ > isNatural > isLNat > isPLNat
proper₁ > U61₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > and₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > take₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > take₂ > isNatural > isLNat > isPLNat
proper₁ > sel₂ > mark₁ > U101^1₁ > isPLNat
proper₁ > sel₂ > isNatural > isLNat > isPLNat
top > isPLNat

Status:

U101^1₁: multiset
mark₁: [1]
active₁: [1]
U101₃: [1,2,3]
tt: multiset
splitAt₂: [1,2]
U11₃: [1,2,3]
U21₂: multiset
U31₂: [2,1]
U41₂: [2,1]
cons₂: multiset
U51₃: multiset
afterNth₂: multiset
U61₂: [1,2]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: [2,1]
U91₂: [1,2]
and₂: [1,2]
isNatural: []
isLNat: multiset
isPLNat: []
take₂: [1,2]
0: multiset
sel₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(189) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U101¹(ok(X1), ok(X2), ok(X3)) → U101¹(X1, X2, X3)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(190) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U101¹(ok(X1), ok(X2), ok(X3)) → U101¹(X1, X2, X3)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U101¹(x1, x2, x3)  =  U101¹(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x2)
U31(x1, x2)  =  U31(x2)
U41(x1, x2)  =  U41(x2)
cons(x1, x2)  =  x2
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  x2
head(x1)  =  head(x1)
afterNth(x1, x2)  =  afterNth(x2)
U61(x1, x2)  =  x1
U71(x1, x2)  =  U71(x1)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1)
U82(x1, x2)  =  x2
U91(x1, x2)  =  U91(x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  x1
0  =  0
sel(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

nil > tt > s₁ > ok₁ > U101^1₁ > mark
nil > tt > afterNth₁ > ok₁ > U101^1₁ > mark
nil > tt > pair₂ > ok₁ > U101^1₁ > mark
0 > tt > s₁ > ok₁ > U101^1₁ > mark
0 > tt > afterNth₁ > ok₁ > U101^1₁ > mark
0 > tt > pair₂ > ok₁ > U101^1₁ > mark
0 > U71₁ > pair₂ > ok₁ > U101^1₁ > mark
proper₁ > U101₃ > ok₁ > U101^1₁ > mark
proper₁ > tt > s₁ > ok₁ > U101^1₁ > mark
proper₁ > tt > afterNth₁ > ok₁ > U101^1₁ > mark
proper₁ > tt > pair₂ > ok₁ > U101^1₁ > mark
proper₁ > splitAt₁ > U81₁ > ok₁ > U101^1₁ > mark
proper₁ > splitAt₁ > and₂ > ok₁ > U101^1₁ > mark
proper₁ > U11₃ > ok₁ > U101^1₁ > mark
proper₁ > U21₁ > ok₁ > U101^1₁ > mark
proper₁ > U41₁ > ok₁ > U101^1₁ > mark
proper₁ > head₁ > U31₁ > ok₁ > U101^1₁ > mark
proper₁ > U71₁ > pair₂ > ok₁ > U101^1₁ > mark
proper₁ > U91₁ > ok₁ > U101^1₁ > mark
top > mark

Status:

U101^1₁: multiset
ok₁: [1]
U101₃: [1,2,3]
tt: multiset
mark: multiset
splitAt₁: [1]
U11₃: [1,3,2]
U21₁: [1]
U31₁: [1]
U41₁: [1]
s₁: [1]
head₁: [1]
afterNth₁: [1]
U71₁: [1]
pair₂: [2,1]
nil: multiset
U81₁: [1]
U91₁: [1]
and₂: [1,2]
0: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(191) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(192) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(193) TRUE

(194) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PROPER(U101(X1, X2, X3)) → PROPER(X2)
PROPER(U101(X1, X2, X3)) → PROPER(X1)
PROPER(U101(X1, X2, X3)) → PROPER(X3)
PROPER(fst(X)) → PROPER(X)
PROPER(splitAt(X1, X2)) → PROPER(X1)
PROPER(splitAt(X1, X2)) → PROPER(X2)
PROPER(U11(X1, X2, X3)) → PROPER(X1)
PROPER(U11(X1, X2, X3)) → PROPER(X2)
PROPER(U11(X1, X2, X3)) → PROPER(X3)
PROPER(snd(X)) → PROPER(X)
PROPER(U21(X1, X2)) → PROPER(X1)
PROPER(U21(X1, X2)) → PROPER(X2)
PROPER(U31(X1, X2)) → PROPER(X1)
PROPER(U31(X1, X2)) → PROPER(X2)
PROPER(U41(X1, X2)) → PROPER(X1)
PROPER(U41(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(natsFrom(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(U51(X1, X2, X3)) → PROPER(X1)
PROPER(U51(X1, X2, X3)) → PROPER(X2)
PROPER(U51(X1, X2, X3)) → PROPER(X3)
PROPER(head(X)) → PROPER(X)
PROPER(afterNth(X1, X2)) → PROPER(X1)
PROPER(afterNth(X1, X2)) → PROPER(X2)
PROPER(U61(X1, X2)) → PROPER(X1)
PROPER(U61(X1, X2)) → PROPER(X2)
PROPER(U71(X1, X2)) → PROPER(X1)
PROPER(U71(X1, X2)) → PROPER(X2)
PROPER(pair(X1, X2)) → PROPER(X1)
PROPER(pair(X1, X2)) → PROPER(X2)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X1)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X2)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X3)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X4)
PROPER(U82(X1, X2)) → PROPER(X1)
PROPER(U82(X1, X2)) → PROPER(X2)
PROPER(U91(X1, X2)) → PROPER(X1)
PROPER(U91(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(isNatural(X)) → PROPER(X)
PROPER(isLNat(X)) → PROPER(X)
PROPER(isPLNat(X)) → PROPER(X)
PROPER(tail(X)) → PROPER(X)
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)
PROPER(sel(X1, X2)) → PROPER(X1)
PROPER(sel(X1, X2)) → PROPER(X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(195) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(U101(X1, X2, X3)) → PROPER(X2)
PROPER(U101(X1, X2, X3)) → PROPER(X1)
PROPER(U101(X1, X2, X3)) → PROPER(X3)
PROPER(splitAt(X1, X2)) → PROPER(X1)
PROPER(splitAt(X1, X2)) → PROPER(X2)
PROPER(U11(X1, X2, X3)) → PROPER(X1)
PROPER(U11(X1, X2, X3)) → PROPER(X2)
PROPER(U11(X1, X2, X3)) → PROPER(X3)
PROPER(snd(X)) → PROPER(X)
PROPER(U21(X1, X2)) → PROPER(X1)
PROPER(U21(X1, X2)) → PROPER(X2)
PROPER(U31(X1, X2)) → PROPER(X1)
PROPER(U31(X1, X2)) → PROPER(X2)
PROPER(U41(X1, X2)) → PROPER(X1)
PROPER(U41(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(natsFrom(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(U51(X1, X2, X3)) → PROPER(X1)
PROPER(U51(X1, X2, X3)) → PROPER(X2)
PROPER(U51(X1, X2, X3)) → PROPER(X3)
PROPER(afterNth(X1, X2)) → PROPER(X1)
PROPER(afterNth(X1, X2)) → PROPER(X2)
PROPER(U61(X1, X2)) → PROPER(X1)
PROPER(U61(X1, X2)) → PROPER(X2)
PROPER(U71(X1, X2)) → PROPER(X1)
PROPER(U71(X1, X2)) → PROPER(X2)
PROPER(pair(X1, X2)) → PROPER(X1)
PROPER(pair(X1, X2)) → PROPER(X2)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X1)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X2)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X3)
PROPER(U81(X1, X2, X3, X4)) → PROPER(X4)
PROPER(U82(X1, X2)) → PROPER(X1)
PROPER(U82(X1, X2)) → PROPER(X2)
PROPER(U91(X1, X2)) → PROPER(X1)
PROPER(U91(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(isNatural(X)) → PROPER(X)
PROPER(tail(X)) → PROPER(X)
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)
PROPER(sel(X1, X2)) → PROPER(X1)
PROPER(sel(X1, X2)) → PROPER(X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  PROPER(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom(x1)
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
sel(x1, x2)  =  sel(x1, x2)
active(x1)  =  active(x1)
tt  =  tt
mark(x1)  =  mark(x1)
nil  =  nil
0  =  0
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

PROPER₁ > mark₁
proper₁ > snd₁ > U61₂ > mark₁
proper₁ > U31₂ > mark₁
proper₁ > U41₂ > cons₂ > U91₂ > mark₁
proper₁ > U41₂ > natsFrom₁ > mark₁
proper₁ > s₁ > mark₁
proper₁ > U51₃ > mark₁
proper₁ > afterNth₂ > U11₃ > splitAt₂ > mark₁
proper₁ > U81₄ > splitAt₂ > mark₁
proper₁ > U81₄ > U82₂ > mark₁
proper₁ > and₂ > mark₁
proper₁ > isNatural₁ > mark₁
proper₁ > tail₁ > U91₂ > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > sel₂ > mark₁
proper₁ > tt > splitAt₂ > mark₁
proper₁ > tt > natsFrom₁ > mark₁
proper₁ > tt > pair₂ > U21₂ > mark₁
proper₁ > tt > pair₂ > cons₂ > U91₂ > mark₁
proper₁ > tt > pair₂ > U61₂ > mark₁
proper₁ > tt > U82₂ > mark₁
proper₁ > nil > mark₁
proper₁ > 0 > U71₂ > mark₁
top > active₁ > snd₁ > U61₂ > mark₁
top > active₁ > U31₂ > mark₁
top > active₁ > U41₂ > cons₂ > U91₂ > mark₁
top > active₁ > U41₂ > natsFrom₁ > mark₁
top > active₁ > s₁ > mark₁
top > active₁ > U51₃ > mark₁
top > active₁ > afterNth₂ > U11₃ > splitAt₂ > mark₁
top > active₁ > U71₂ > mark₁
top > active₁ > U81₄ > splitAt₂ > mark₁
top > active₁ > U81₄ > U82₂ > mark₁
top > active₁ > and₂ > mark₁
top > active₁ > isNatural₁ > mark₁
top > active₁ > tail₁ > U91₂ > mark₁
top > active₁ > take₂ > U101₃ > mark₁
top > active₁ > sel₂ > mark₁
top > active₁ > tt > splitAt₂ > mark₁
top > active₁ > tt > natsFrom₁ > mark₁
top > active₁ > tt > pair₂ > U21₂ > mark₁
top > active₁ > tt > pair₂ > cons₂ > U91₂ > mark₁
top > active₁ > tt > pair₂ > U61₂ > mark₁
top > active₁ > tt > U82₂ > mark₁
top > active₁ > nil > mark₁

Status:

PROPER₁: multiset
U101₃: [2,1,3]
splitAt₂: [1,2]
U11₃: [1,2,3]
snd₁: [1]
U21₂: [1,2]
U31₂: [2,1]
U41₂: [2,1]
cons₂: [1,2]
natsFrom₁: multiset
s₁: multiset
U51₃: [3,1,2]
afterNth₂: [2,1]
U61₂: [2,1]
U71₂: [2,1]
pair₂: [1,2]
U81₄: [3,2,4,1]
U82₂: [2,1]
U91₂: [1,2]
and₂: [1,2]
isNatural₁: multiset
tail₁: [1]
take₂: [1,2]
sel₂: [1,2]
active₁: [1]
tt: multiset
mark₁: [1]
nil: multiset
0: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(196) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PROPER(fst(X)) → PROPER(X)
PROPER(head(X)) → PROPER(X)
PROPER(isLNat(X)) → PROPER(X)
PROPER(isPLNat(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(197) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(isLNat(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  PROPER(x1)
fst(x1)  =  x1
head(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
isPLNat(x1)  =  x1
active(x1)  =  active
U101(x1, x2, x3)  =  x1
tt  =  tt
mark(x1)  =  mark
splitAt(x1, x2)  =  splitAt
U11(x1, x2, x3)  =  x1
snd(x1)  =  x1
U21(x1, x2)  =  U21
U31(x1, x2)  =  U31
U41(x1, x2)  =  U41
cons(x1, x2)  =  x1
natsFrom(x1)  =  x1
s(x1)  =  s
U51(x1, x2, x3)  =  x1
afterNth(x1, x2)  =  afterNth
U61(x1, x2)  =  x1
U71(x1, x2)  =  x1
pair(x1, x2)  =  pair
nil  =  nil
U81(x1, x2, x3, x4)  =  x1
U82(x1, x2)  =  x1
U91(x1, x2)  =  U91
and(x1, x2)  =  x1
isNatural(x1)  =  x1
tail(x1)  =  x1
take(x1, x2)  =  take
0  =  0
sel(x1, x2)  =  sel
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

PROPER₁ > mark
0 > isLNat₁ > mark
0 > tt > mark
0 > ok > mark
top > active > splitAt > proper₁ > tt > mark
top > active > splitAt > proper₁ > U21 > ok > mark
top > active > splitAt > proper₁ > U31 > ok > mark
top > active > splitAt > proper₁ > s > isLNat₁ > mark
top > active > splitAt > proper₁ > s > ok > mark
top > active > splitAt > proper₁ > afterNth > isLNat₁ > mark
top > active > splitAt > proper₁ > afterNth > ok > mark
top > active > splitAt > proper₁ > pair > isLNat₁ > mark
top > active > splitAt > proper₁ > pair > ok > mark
top > active > splitAt > proper₁ > nil > mark
top > active > splitAt > proper₁ > U91 > ok > mark
top > active > splitAt > proper₁ > sel > isLNat₁ > mark
top > active > splitAt > proper₁ > sel > ok > mark
top > active > U41 > proper₁ > tt > mark
top > active > U41 > proper₁ > U21 > ok > mark
top > active > U41 > proper₁ > U31 > ok > mark
top > active > U41 > proper₁ > s > isLNat₁ > mark
top > active > U41 > proper₁ > s > ok > mark
top > active > U41 > proper₁ > afterNth > isLNat₁ > mark
top > active > U41 > proper₁ > afterNth > ok > mark
top > active > U41 > proper₁ > pair > isLNat₁ > mark
top > active > U41 > proper₁ > pair > ok > mark
top > active > U41 > proper₁ > nil > mark
top > active > U41 > proper₁ > U91 > ok > mark
top > active > U41 > proper₁ > sel > isLNat₁ > mark
top > active > U41 > proper₁ > sel > ok > mark
top > active > take > proper₁ > tt > mark
top > active > take > proper₁ > U21 > ok > mark
top > active > take > proper₁ > U31 > ok > mark
top > active > take > proper₁ > s > isLNat₁ > mark
top > active > take > proper₁ > s > ok > mark
top > active > take > proper₁ > afterNth > isLNat₁ > mark
top > active > take > proper₁ > afterNth > ok > mark
top > active > take > proper₁ > pair > isLNat₁ > mark
top > active > take > proper₁ > pair > ok > mark
top > active > take > proper₁ > nil > mark
top > active > take > proper₁ > U91 > ok > mark
top > active > take > proper₁ > sel > isLNat₁ > mark
top > active > take > proper₁ > sel > ok > mark

Status:

PROPER₁: multiset
isLNat₁: [1]
active: []
tt: multiset
mark: []
splitAt: multiset
U21: multiset
U31: multiset
U41: []
s: []
afterNth: multiset
pair: []
nil: multiset
U91: multiset
take: multiset
0: multiset
sel: []
proper₁: multiset
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(198) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PROPER(fst(X)) → PROPER(X)
PROPER(head(X)) → PROPER(X)
PROPER(isPLNat(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(199) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(fst(X)) → PROPER(X)
PROPER(isPLNat(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  PROPER(x1)
fst(x1)  =  fst(x1)
head(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
mark(x1)  =  mark
splitAt(x1, x2)  =  splitAt
U11(x1, x2, x3)  =  x2
snd(x1)  =  x1
U21(x1, x2)  =  U21
U31(x1, x2)  =  U31(x1)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  natsFrom
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x2
U71(x1, x2)  =  x1
pair(x1, x2)  =  pair
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1)
U91(x1, x2)  =  U91
and(x1, x2)  =  and
isNatural(x1)  =  x1
isLNat(x1)  =  isLNat(x1)
tail(x1)  =  tail
take(x1, x2)  =  x1
0  =  0
sel(x1, x2)  =  x1
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

splitAt > active₁ > fst₁ > PROPER₁ > mark
splitAt > active₁ > fst₁ > isPLNat₁ > mark
splitAt > active₁ > fst₁ > isLNat₁ > mark
splitAt > active₁ > U101₃ > mark
splitAt > active₁ > U21 > mark
splitAt > active₁ > U41₂ > s₁ > isLNat₁ > mark
splitAt > active₁ > cons₂ > U31₁ > mark
splitAt > active₁ > cons₂ > U81₄ > mark
splitAt > active₁ > cons₂ > isLNat₁ > mark
splitAt > active₁ > U51 > mark
splitAt > active₁ > afterNth₂ > isLNat₁ > mark
splitAt > active₁ > pair > isLNat₁ > mark
splitAt > active₁ > U82₁ > mark
splitAt > proper₁ > fst₁ > PROPER₁ > mark
splitAt > proper₁ > fst₁ > isPLNat₁ > mark
splitAt > proper₁ > fst₁ > isLNat₁ > mark
splitAt > proper₁ > U101₃ > mark
splitAt > proper₁ > U21 > mark
splitAt > proper₁ > U41₂ > s₁ > isLNat₁ > mark
splitAt > proper₁ > cons₂ > U31₁ > mark
splitAt > proper₁ > cons₂ > U81₄ > mark
splitAt > proper₁ > cons₂ > isLNat₁ > mark
splitAt > proper₁ > U51 > mark
splitAt > proper₁ > afterNth₂ > isLNat₁ > mark
splitAt > proper₁ > pair > isLNat₁ > mark
splitAt > proper₁ > U82₁ > mark
natsFrom > active₁ > fst₁ > PROPER₁ > mark
natsFrom > active₁ > fst₁ > isPLNat₁ > mark
natsFrom > active₁ > fst₁ > isLNat₁ > mark
natsFrom > active₁ > U101₃ > mark
natsFrom > active₁ > U21 > mark
natsFrom > active₁ > U41₂ > s₁ > isLNat₁ > mark
natsFrom > active₁ > cons₂ > U31₁ > mark
natsFrom > active₁ > cons₂ > U81₄ > mark
natsFrom > active₁ > cons₂ > isLNat₁ > mark
natsFrom > active₁ > U51 > mark
natsFrom > active₁ > afterNth₂ > isLNat₁ > mark
natsFrom > active₁ > pair > isLNat₁ > mark
natsFrom > active₁ > U82₁ > mark
natsFrom > proper₁ > fst₁ > PROPER₁ > mark
natsFrom > proper₁ > fst₁ > isPLNat₁ > mark
natsFrom > proper₁ > fst₁ > isLNat₁ > mark
natsFrom > proper₁ > U101₃ > mark
natsFrom > proper₁ > U21 > mark
natsFrom > proper₁ > U41₂ > s₁ > isLNat₁ > mark
natsFrom > proper₁ > cons₂ > U31₁ > mark
natsFrom > proper₁ > cons₂ > U81₄ > mark
natsFrom > proper₁ > cons₂ > isLNat₁ > mark
natsFrom > proper₁ > U51 > mark
natsFrom > proper₁ > afterNth₂ > isLNat₁ > mark
natsFrom > proper₁ > pair > isLNat₁ > mark
natsFrom > proper₁ > U82₁ > mark
nil > mark
U91 > active₁ > fst₁ > PROPER₁ > mark
U91 > active₁ > fst₁ > isPLNat₁ > mark
U91 > active₁ > fst₁ > isLNat₁ > mark
U91 > active₁ > U101₃ > mark
U91 > active₁ > U21 > mark
U91 > active₁ > U41₂ > s₁ > isLNat₁ > mark
U91 > active₁ > cons₂ > U31₁ > mark
U91 > active₁ > cons₂ > U81₄ > mark
U91 > active₁ > cons₂ > isLNat₁ > mark
U91 > active₁ > U51 > mark
U91 > active₁ > afterNth₂ > isLNat₁ > mark
U91 > active₁ > pair > isLNat₁ > mark
U91 > active₁ > U82₁ > mark
U91 > proper₁ > fst₁ > PROPER₁ > mark
U91 > proper₁ > fst₁ > isPLNat₁ > mark
U91 > proper₁ > fst₁ > isLNat₁ > mark
U91 > proper₁ > U101₃ > mark
U91 > proper₁ > U21 > mark
U91 > proper₁ > U41₂ > s₁ > isLNat₁ > mark
U91 > proper₁ > cons₂ > U31₁ > mark
U91 > proper₁ > cons₂ > U81₄ > mark
U91 > proper₁ > cons₂ > isLNat₁ > mark
U91 > proper₁ > U51 > mark
U91 > proper₁ > afterNth₂ > isLNat₁ > mark
U91 > proper₁ > pair > isLNat₁ > mark
U91 > proper₁ > U82₁ > mark
and > active₁ > fst₁ > PROPER₁ > mark
and > active₁ > fst₁ > isPLNat₁ > mark
and > active₁ > fst₁ > isLNat₁ > mark
and > active₁ > U101₃ > mark
and > active₁ > U21 > mark
and > active₁ > U41₂ > s₁ > isLNat₁ > mark
and > active₁ > cons₂ > U31₁ > mark
and > active₁ > cons₂ > U81₄ > mark
and > active₁ > cons₂ > isLNat₁ > mark
and > active₁ > U51 > mark
and > active₁ > afterNth₂ > isLNat₁ > mark
and > active₁ > pair > isLNat₁ > mark
and > active₁ > U82₁ > mark
and > proper₁ > fst₁ > PROPER₁ > mark
and > proper₁ > fst₁ > isPLNat₁ > mark
and > proper₁ > fst₁ > isLNat₁ > mark
and > proper₁ > U101₃ > mark
and > proper₁ > U21 > mark
and > proper₁ > U41₂ > s₁ > isLNat₁ > mark
and > proper₁ > cons₂ > U31₁ > mark
and > proper₁ > cons₂ > U81₄ > mark
and > proper₁ > cons₂ > isLNat₁ > mark
and > proper₁ > U51 > mark
and > proper₁ > afterNth₂ > isLNat₁ > mark
and > proper₁ > pair > isLNat₁ > mark
and > proper₁ > U82₁ > mark
tail > active₁ > fst₁ > PROPER₁ > mark
tail > active₁ > fst₁ > isPLNat₁ > mark
tail > active₁ > fst₁ > isLNat₁ > mark
tail > active₁ > U101₃ > mark
tail > active₁ > U21 > mark
tail > active₁ > U41₂ > s₁ > isLNat₁ > mark
tail > active₁ > cons₂ > U31₁ > mark
tail > active₁ > cons₂ > U81₄ > mark
tail > active₁ > cons₂ > isLNat₁ > mark
tail > active₁ > U51 > mark
tail > active₁ > afterNth₂ > isLNat₁ > mark
tail > active₁ > pair > isLNat₁ > mark
tail > active₁ > U82₁ > mark
tail > proper₁ > fst₁ > PROPER₁ > mark
tail > proper₁ > fst₁ > isPLNat₁ > mark
tail > proper₁ > fst₁ > isLNat₁ > mark
tail > proper₁ > U101₃ > mark
tail > proper₁ > U21 > mark
tail > proper₁ > U41₂ > s₁ > isLNat₁ > mark
tail > proper₁ > cons₂ > U31₁ > mark
tail > proper₁ > cons₂ > U81₄ > mark
tail > proper₁ > cons₂ > isLNat₁ > mark
tail > proper₁ > U51 > mark
tail > proper₁ > afterNth₂ > isLNat₁ > mark
tail > proper₁ > pair > isLNat₁ > mark
tail > proper₁ > U82₁ > mark
0 > tt > fst₁ > PROPER₁ > mark
0 > tt > fst₁ > isPLNat₁ > mark
0 > tt > fst₁ > isLNat₁ > mark
0 > tt > cons₂ > U31₁ > mark
0 > tt > cons₂ > U81₄ > mark
0 > tt > cons₂ > isLNat₁ > mark
0 > tt > s₁ > isLNat₁ > mark
0 > tt > afterNth₂ > isLNat₁ > mark
0 > tt > pair > isLNat₁ > mark
0 > tt > U82₁ > mark
top > active₁ > fst₁ > PROPER₁ > mark
top > active₁ > fst₁ > isPLNat₁ > mark
top > active₁ > fst₁ > isLNat₁ > mark
top > active₁ > U101₃ > mark
top > active₁ > U21 > mark
top > active₁ > U41₂ > s₁ > isLNat₁ > mark
top > active₁ > cons₂ > U31₁ > mark
top > active₁ > cons₂ > U81₄ > mark
top > active₁ > cons₂ > isLNat₁ > mark
top > active₁ > U51 > mark
top > active₁ > afterNth₂ > isLNat₁ > mark
top > active₁ > pair > isLNat₁ > mark
top > active₁ > U82₁ > mark
top > proper₁ > fst₁ > PROPER₁ > mark
top > proper₁ > fst₁ > isPLNat₁ > mark
top > proper₁ > fst₁ > isLNat₁ > mark
top > proper₁ > U101₃ > mark
top > proper₁ > U21 > mark
top > proper₁ > U41₂ > s₁ > isLNat₁ > mark
top > proper₁ > cons₂ > U31₁ > mark
top > proper₁ > cons₂ > U81₄ > mark
top > proper₁ > cons₂ > isLNat₁ > mark
top > proper₁ > U51 > mark
top > proper₁ > afterNth₂ > isLNat₁ > mark
top > proper₁ > pair > isLNat₁ > mark
top > proper₁ > U82₁ > mark

Status:

PROPER₁: multiset
fst₁: [1]
isPLNat₁: multiset
active₁: [1]
U101₃: [3,1,2]
tt: multiset
mark: []
splitAt: []
U21: multiset
U31₁: [1]
U41₂: [2,1]
cons₂: [2,1]
natsFrom: []
s₁: [1]
U51: multiset
afterNth₂: multiset
pair: []
nil: multiset
U81₄: [1,4,2,3]
U82₁: [1]
U91: []
and: []
isLNat₁: multiset
tail: []
0: multiset
proper₁: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(200) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PROPER(head(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(201) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(head(X)) → PROPER(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  PROPER(x1)
head(x1)  =  head(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
mark(x1)  =  mark(x1)
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

PROPER₁ > mark₁
active₁ > tt > head₁ > ok > mark₁
active₁ > tt > splitAt₂ > U71₂ > ok > mark₁
active₁ > tt > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
active₁ > tt > s₁ > ok > mark₁
active₁ > tt > pair₂ > U21₂ > ok > mark₁
active₁ > tt > pair₂ > cons₂ > ok > mark₁
active₁ > U11₃ > splitAt₂ > U71₂ > ok > mark₁
active₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
active₁ > snd₁ > U61₂ > ok > mark₁
active₁ > snd₁ > and₂ > ok > mark₁
active₁ > snd₁ > isPLNat₁ > ok > mark₁
active₁ > U31₂ > ok > mark₁
active₁ > U41₂ > cons₂ > ok > mark₁
active₁ > U51₃ > head₁ > ok > mark₁
active₁ > afterNth₂ > and₂ > ok > mark₁
active₁ > nil > ok > mark₁
active₁ > tail₁ > U91₂ > ok > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > take₂ > and₂ > ok > mark₁
active₁ > sel₂ > ok > mark₁
proper₁ > tt > head₁ > ok > mark₁
proper₁ > tt > splitAt₂ > U71₂ > ok > mark₁
proper₁ > tt > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
proper₁ > tt > s₁ > ok > mark₁
proper₁ > tt > pair₂ > U21₂ > ok > mark₁
proper₁ > tt > pair₂ > cons₂ > ok > mark₁
proper₁ > U11₃ > splitAt₂ > U71₂ > ok > mark₁
proper₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
proper₁ > snd₁ > U61₂ > ok > mark₁
proper₁ > snd₁ > and₂ > ok > mark₁
proper₁ > snd₁ > isPLNat₁ > ok > mark₁
proper₁ > U31₂ > ok > mark₁
proper₁ > U41₂ > cons₂ > ok > mark₁
proper₁ > U51₃ > head₁ > ok > mark₁
proper₁ > afterNth₂ > and₂ > ok > mark₁
proper₁ > nil > ok > mark₁
proper₁ > tail₁ > U91₂ > ok > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > take₂ > and₂ > ok > mark₁
proper₁ > 0 > U71₂ > ok > mark₁
proper₁ > sel₂ > ok > mark₁
top > mark₁

Status:

PROPER₁: [1]
head₁: [1]
active₁: [1]
U101₃: [2,1,3]
tt: multiset
mark₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [2,1]
U41₂: multiset
cons₂: [1,2]
s₁: [1]
U51₃: [1,3,2]
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: [1,2]
U91₂: [1,2]
and₂: [1,2]
isPLNat₁: multiset
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: multiset
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(202) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(203) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(204) TRUE

(205) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(U101(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X2)
ACTIVE(U11(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(U21(X1, X2)) → ACTIVE(X1)
ACTIVE(U31(X1, X2)) → ACTIVE(X1)
ACTIVE(U41(X1, X2)) → ACTIVE(X1)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(U51(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X2)
ACTIVE(U61(X1, X2)) → ACTIVE(X1)
ACTIVE(U71(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → ACTIVE(X2)
ACTIVE(U81(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(U82(X1, X2)) → ACTIVE(X1)
ACTIVE(U91(X1, X2)) → ACTIVE(X1)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(tail(X)) → ACTIVE(X)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X2)
ACTIVE(sel(X1, X2)) → ACTIVE(X1)
ACTIVE(sel(X1, X2)) → ACTIVE(X2)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(206) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(U101(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X2)
ACTIVE(U11(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(U21(X1, X2)) → ACTIVE(X1)
ACTIVE(U31(X1, X2)) → ACTIVE(X1)
ACTIVE(U41(X1, X2)) → ACTIVE(X1)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(U51(X1, X2, X3)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X2)
ACTIVE(U61(X1, X2)) → ACTIVE(X1)
ACTIVE(U71(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → ACTIVE(X2)
ACTIVE(U81(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(U82(X1, X2)) → ACTIVE(X1)
ACTIVE(U91(X1, X2)) → ACTIVE(X1)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X2)
ACTIVE(sel(X1, X2)) → ACTIVE(X1)
ACTIVE(sel(X1, X2)) → ACTIVE(X2)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  x1
fst(x1)  =  x1
U101(x1, x2, x3)  =  U101(x1, x2, x3)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  x1
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
head(x1)  =  x1
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
tail(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
sel(x1, x2)  =  sel(x1, x2)
active(x1)  =  active(x1)
tt  =  tt
mark(x1)  =  mark(x1)
nil  =  nil
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  x1
0  =  0
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

active₁ > U11₃ > splitAt₂ > U71₂ > mark₁ > nil
active₁ > U11₃ > splitAt₂ > U71₂ > ok > nil
active₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > mark₁ > nil
active₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > ok > nil
active₁ > U41₂ > mark₁ > nil
active₁ > U41₂ > ok > nil
active₁ > pair₂ > U21₂ > mark₁ > nil
active₁ > pair₂ > U21₂ > ok > nil
active₁ > pair₂ > cons₂ > U31₂ > mark₁ > nil
active₁ > pair₂ > cons₂ > U31₂ > ok > nil
active₁ > pair₂ > cons₂ > U81₄ > U82₂ > mark₁ > nil
active₁ > pair₂ > cons₂ > U81₄ > U82₂ > ok > nil
active₁ > pair₂ > U61₂ > mark₁ > nil
active₁ > pair₂ > U61₂ > ok > nil
active₁ > pair₂ > and₂ > mark₁ > nil
active₁ > pair₂ > and₂ > ok > nil
active₁ > U91₂ > mark₁ > nil
active₁ > U91₂ > ok > nil
active₁ > take₂ > U101₃ > mark₁ > nil
active₁ > take₂ > U101₃ > ok > nil
active₁ > sel₂ > U51₃ > afterNth₂ > mark₁ > nil
active₁ > sel₂ > U51₃ > afterNth₂ > ok > nil
active₁ > tt > splitAt₂ > U71₂ > mark₁ > nil
active₁ > tt > splitAt₂ > U71₂ > ok > nil
active₁ > tt > splitAt₂ > U81₄ > U82₂ > mark₁ > nil
active₁ > tt > splitAt₂ > U81₄ > U82₂ > ok > nil
active₁ > tt > cons₂ > U31₂ > mark₁ > nil
active₁ > tt > cons₂ > U31₂ > ok > nil
active₁ > tt > cons₂ > U81₄ > U82₂ > mark₁ > nil
active₁ > tt > cons₂ > U81₄ > U82₂ > ok > nil
active₁ > tt > s₁ > U81₄ > U82₂ > mark₁ > nil
active₁ > tt > s₁ > U81₄ > U82₂ > ok > nil
active₁ > tt > afterNth₂ > mark₁ > nil
active₁ > tt > afterNth₂ > ok > nil
proper₁ > U11₃ > splitAt₂ > U71₂ > mark₁ > nil
proper₁ > U11₃ > splitAt₂ > U71₂ > ok > nil
proper₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > mark₁ > nil
proper₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > ok > nil
proper₁ > U41₂ > mark₁ > nil
proper₁ > U41₂ > ok > nil
proper₁ > pair₂ > U21₂ > mark₁ > nil
proper₁ > pair₂ > U21₂ > ok > nil
proper₁ > pair₂ > cons₂ > U31₂ > mark₁ > nil
proper₁ > pair₂ > cons₂ > U31₂ > ok > nil
proper₁ > pair₂ > cons₂ > U81₄ > U82₂ > mark₁ > nil
proper₁ > pair₂ > cons₂ > U81₄ > U82₂ > ok > nil
proper₁ > pair₂ > U61₂ > mark₁ > nil
proper₁ > pair₂ > U61₂ > ok > nil
proper₁ > pair₂ > and₂ > mark₁ > nil
proper₁ > pair₂ > and₂ > ok > nil
proper₁ > U91₂ > mark₁ > nil
proper₁ > U91₂ > ok > nil
proper₁ > take₂ > U101₃ > mark₁ > nil
proper₁ > take₂ > U101₃ > ok > nil
proper₁ > sel₂ > U51₃ > afterNth₂ > mark₁ > nil
proper₁ > sel₂ > U51₃ > afterNth₂ > ok > nil
proper₁ > tt > splitAt₂ > U71₂ > mark₁ > nil
proper₁ > tt > splitAt₂ > U71₂ > ok > nil
proper₁ > tt > splitAt₂ > U81₄ > U82₂ > mark₁ > nil
proper₁ > tt > splitAt₂ > U81₄ > U82₂ > ok > nil
proper₁ > tt > cons₂ > U31₂ > mark₁ > nil
proper₁ > tt > cons₂ > U31₂ > ok > nil
proper₁ > tt > cons₂ > U81₄ > U82₂ > mark₁ > nil
proper₁ > tt > cons₂ > U81₄ > U82₂ > ok > nil
proper₁ > tt > s₁ > U81₄ > U82₂ > mark₁ > nil
proper₁ > tt > s₁ > U81₄ > U82₂ > ok > nil
proper₁ > tt > afterNth₂ > mark₁ > nil
proper₁ > tt > afterNth₂ > ok > nil
proper₁ > 0 > U71₂ > mark₁ > nil
proper₁ > 0 > U71₂ > ok > nil
top > nil

Status:

U101₃: [1,3,2]
splitAt₂: [1,2]
U11₃: [1,3,2]
U21₂: [1,2]
U31₂: [2,1]
U41₂: [1,2]
cons₂: [2,1]
s₁: [1]
U51₃: [1,2,3]
afterNth₂: [2,1]
U61₂: [2,1]
U71₂: multiset
pair₂: [1,2]
U81₄: multiset
U82₂: [1,2]
U91₂: multiset
and₂: [1,2]
take₂: [1,2]
sel₂: [2,1]
active₁: [1]
tt: multiset
mark₁: [1]
nil: multiset
0: multiset
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(207) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(208) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  ACTIVE(x1)
fst(x1)  =  fst(x1)
snd(x1)  =  x1
natsFrom(x1)  =  natsFrom(x1)
head(x1)  =  x1
tail(x1)  =  tail(x1)
active(x1)  =  x1
U101(x1, x2, x3)  =  x1
tt  =  tt
mark(x1)  =  mark
splitAt(x1, x2)  =  x1
U11(x1, x2, x3)  =  x1
U21(x1, x2)  =  x1
U31(x1, x2)  =  U31
U41(x1, x2)  =  x2
cons(x1, x2)  =  x1
s(x1)  =  s
U51(x1, x2, x3)  =  x3
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  x1
U71(x1, x2)  =  U71
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81
U82(x1, x2)  =  U82(x2)
U91(x1, x2)  =  U91
and(x1, x2)  =  x2
isNatural(x1)  =  isNatural
isLNat(x1)  =  isLNat
isPLNat(x1)  =  isPLNat(x1)
take(x1, x2)  =  take
0  =  0
sel(x1, x2)  =  sel
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

proper₁ > fst₁ > ACTIVE₁ > mark
proper₁ > fst₁ > isPLNat₁ > isLNat > mark
proper₁ > natsFrom₁ > ACTIVE₁ > mark
proper₁ > tail₁ > isLNat > mark
proper₁ > U31 > mark
proper₁ > s > isLNat > mark
proper₁ > afterNth₂ > isLNat > mark
proper₁ > U71 > pair₂ > isLNat > mark
proper₁ > U71 > nil > tt > mark
proper₁ > U81 > mark
proper₁ > U82₁ > pair₂ > isLNat > mark
proper₁ > U91 > mark
proper₁ > isNatural > tt > mark
proper₁ > isNatural > isLNat > mark
proper₁ > take > mark
proper₁ > 0 > tt > mark
proper₁ > 0 > isLNat > mark
proper₁ > sel > isLNat > mark
top > mark

Status:

ACTIVE₁: multiset
fst₁: multiset
natsFrom₁: [1]
tail₁: [1]
tt: multiset
mark: multiset
U31: multiset
s: []
afterNth₂: [2,1]
U71: multiset
pair₂: [2,1]
nil: multiset
U81: []
U82₁: [1]
U91: multiset
isNatural: []
isLNat: multiset
isPLNat₁: [1]
take: []
0: multiset
sel: []
proper₁: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(209) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(210) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(snd(X)) → ACTIVE(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  ACTIVE(x1)
snd(x1)  =  snd(x1)
head(x1)  =  x1
active(x1)  =  x1
U101(x1, x2, x3)  =  U101
tt  =  tt
mark(x1)  =  mark
fst(x1)  =  fst(x1)
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
U21(x1, x2)  =  U21(x2)
U31(x1, x2)  =  x2
U41(x1, x2)  =  U41
cons(x1, x2)  =  x2
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  x3
afterNth(x1, x2)  =  x1
U61(x1, x2)  =  U61(x2)
U71(x1, x2)  =  U71
pair(x1, x2)  =  pair
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x3, x4)
U82(x1, x2)  =  x1
U91(x1, x2)  =  x2
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  isNatural(x1)
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail
take(x1, x2)  =  take(x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

ACTIVE₁ > mark
proper₁ > fst₁ > isPLNat₁ > and₂ > mark
proper₁ > U11₃ > snd₁ > and₂ > mark
proper₁ > U11₃ > splitAt₂ > and₂ > mark
proper₁ > U21₁ > mark
proper₁ > U41 > mark
proper₁ > s₁ > and₂ > mark
proper₁ > U61₁ > mark
proper₁ > U81₂ > splitAt₂ > and₂ > mark
proper₁ > tail > mark
proper₁ > take₁ > U101 > mark
proper₁ > take₁ > isNatural₁ > tt > mark
proper₁ > take₁ > isNatural₁ > and₂ > mark
proper₁ > 0 > U71 > pair > and₂ > mark
proper₁ > 0 > U71 > nil > tt > mark
proper₁ > sel₂ > isNatural₁ > tt > mark
proper₁ > sel₂ > isNatural₁ > and₂ > mark
top > mark

Status:

ACTIVE₁: multiset
snd₁: multiset
U101: multiset
tt: multiset
mark: []
fst₁: multiset
splitAt₂: [1,2]
U11₃: [1,2,3]
U21₁: [1]
U41: []
s₁: [1]
U61₁: [1]
U71: multiset
pair: multiset
nil: multiset
U81₂: [1,2]
and₂: [2,1]
isNatural₁: multiset
isPLNat₁: [1]
tail: []
take₁: [1]
0: multiset
sel₂: [2,1]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(211) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(head(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(212) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(head(X)) → ACTIVE(X)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  ACTIVE(x1)
head(x1)  =  head(x1)
active(x1)  =  active(x1)
U101(x1, x2, x3)  =  U101(x1, x2, x3)
tt  =  tt
mark(x1)  =  mark(x1)
fst(x1)  =  x1
splitAt(x1, x2)  =  splitAt(x1, x2)
U11(x1, x2, x3)  =  U11(x1, x2, x3)
snd(x1)  =  snd(x1)
U21(x1, x2)  =  U21(x1, x2)
U31(x1, x2)  =  U31(x1, x2)
U41(x1, x2)  =  U41(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
natsFrom(x1)  =  x1
s(x1)  =  s(x1)
U51(x1, x2, x3)  =  U51(x1, x2, x3)
afterNth(x1, x2)  =  afterNth(x1, x2)
U61(x1, x2)  =  U61(x1, x2)
U71(x1, x2)  =  U71(x1, x2)
pair(x1, x2)  =  pair(x1, x2)
nil  =  nil
U81(x1, x2, x3, x4)  =  U81(x1, x2, x3, x4)
U82(x1, x2)  =  U82(x1, x2)
U91(x1, x2)  =  U91(x1, x2)
and(x1, x2)  =  and(x1, x2)
isNatural(x1)  =  x1
isLNat(x1)  =  x1
isPLNat(x1)  =  isPLNat(x1)
tail(x1)  =  tail(x1)
take(x1, x2)  =  take(x1, x2)
0  =  0
sel(x1, x2)  =  sel(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok
top(x1)  =  top

Recursive path order with status [RPO].
Precedence:

ACTIVE₁ > mark₁
active₁ > tt > head₁ > ok > mark₁
active₁ > tt > splitAt₂ > U71₂ > ok > mark₁
active₁ > tt > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
active₁ > tt > s₁ > ok > mark₁
active₁ > tt > pair₂ > U21₂ > ok > mark₁
active₁ > tt > pair₂ > cons₂ > ok > mark₁
active₁ > U11₃ > splitAt₂ > U71₂ > ok > mark₁
active₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
active₁ > snd₁ > U61₂ > ok > mark₁
active₁ > snd₁ > and₂ > ok > mark₁
active₁ > snd₁ > isPLNat₁ > ok > mark₁
active₁ > U31₂ > ok > mark₁
active₁ > U41₂ > cons₂ > ok > mark₁
active₁ > U51₃ > head₁ > ok > mark₁
active₁ > afterNth₂ > and₂ > ok > mark₁
active₁ > nil > ok > mark₁
active₁ > tail₁ > U91₂ > ok > mark₁
active₁ > take₂ > U101₃ > mark₁
active₁ > take₂ > and₂ > ok > mark₁
active₁ > sel₂ > ok > mark₁
proper₁ > tt > head₁ > ok > mark₁
proper₁ > tt > splitAt₂ > U71₂ > ok > mark₁
proper₁ > tt > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
proper₁ > tt > s₁ > ok > mark₁
proper₁ > tt > pair₂ > U21₂ > ok > mark₁
proper₁ > tt > pair₂ > cons₂ > ok > mark₁
proper₁ > U11₃ > splitAt₂ > U71₂ > ok > mark₁
proper₁ > U11₃ > splitAt₂ > U81₄ > U82₂ > cons₂ > ok > mark₁
proper₁ > snd₁ > U61₂ > ok > mark₁
proper₁ > snd₁ > and₂ > ok > mark₁
proper₁ > snd₁ > isPLNat₁ > ok > mark₁
proper₁ > U31₂ > ok > mark₁
proper₁ > U41₂ > cons₂ > ok > mark₁
proper₁ > U51₃ > head₁ > ok > mark₁
proper₁ > afterNth₂ > and₂ > ok > mark₁
proper₁ > nil > ok > mark₁
proper₁ > tail₁ > U91₂ > ok > mark₁
proper₁ > take₂ > U101₃ > mark₁
proper₁ > take₂ > and₂ > ok > mark₁
proper₁ > 0 > U71₂ > ok > mark₁
proper₁ > sel₂ > ok > mark₁
top > mark₁

Status:

ACTIVE₁: [1]
head₁: [1]
active₁: [1]
U101₃: [2,1,3]
tt: multiset
mark₁: [1]
splitAt₂: [1,2]
U11₃: [3,1,2]
snd₁: [1]
U21₂: [2,1]
U31₂: [2,1]
U41₂: multiset
cons₂: [1,2]
s₁: [1]
U51₃: [1,3,2]
afterNth₂: [1,2]
U61₂: [1,2]
U71₂: [1,2]
pair₂: [1,2]
nil: multiset
U81₄: multiset
U82₂: [1,2]
U91₂: [1,2]
and₂: [1,2]
isPLNat₁: multiset
tail₁: [1]
take₂: [1,2]
0: multiset
sel₂: multiset
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(213) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(214) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(215) TRUE

(216) Obligation:

Q DP problem:
The TRS P consists of the following rules:

TOP(ok(X)) → TOP(active(X))
TOP(mark(X)) → TOP(proper(X))

The TRS R consists of the following rules:

active(U101(tt, N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(tt, N, XS)) → mark(snd(splitAt(N, XS)))
active(U21(tt, X)) → mark(X)
active(U31(tt, N)) → mark(N)
active(U41(tt, N)) → mark(cons(N, natsFrom(s(N))))
active(U51(tt, N, XS)) → mark(head(afterNth(N, XS)))
active(U61(tt, Y)) → mark(Y)
active(U71(tt, XS)) → mark(pair(nil, XS))
active(U81(tt, N, X, XS)) → mark(U82(splitAt(N, XS), X))
active(U82(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(U91(tt, XS)) → mark(XS)
active(afterNth(N, XS)) → mark(U11(and(isNatural(N), isLNat(XS)), N, XS))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(U21(and(isLNat(X), isLNat(Y)), X))
active(head(cons(N, XS))) → mark(U31(and(isNatural(N), isLNat(XS)), N))
active(isLNat(nil)) → mark(tt)
active(isLNat(afterNth(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(cons(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isLNat(fst(V1))) → mark(isPLNat(V1))
active(isLNat(natsFrom(V1))) → mark(isNatural(V1))
active(isLNat(snd(V1))) → mark(isPLNat(V1))
active(isLNat(tail(V1))) → mark(isLNat(V1))
active(isLNat(take(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isNatural(0)) → mark(tt)
active(isNatural(head(V1))) → mark(isLNat(V1))
active(isNatural(s(V1))) → mark(isNatural(V1))
active(isNatural(sel(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(isPLNat(pair(V1, V2))) → mark(and(isLNat(V1), isLNat(V2)))
active(isPLNat(splitAt(V1, V2))) → mark(and(isNatural(V1), isLNat(V2)))
active(natsFrom(N)) → mark(U41(isNatural(N), N))
active(sel(N, XS)) → mark(U51(and(isNatural(N), isLNat(XS)), N, XS))
active(snd(pair(X, Y))) → mark(U61(and(isLNat(X), isLNat(Y)), Y))
active(splitAt(0, XS)) → mark(U71(isLNat(XS), XS))
active(splitAt(s(N), cons(X, XS))) → mark(U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS))
active(tail(cons(N, XS))) → mark(U91(and(isNatural(N), isLNat(XS)), XS))
active(take(N, XS)) → mark(U101(and(isNatural(N), isLNat(XS)), N, XS))
active(U101(X1, X2, X3)) → U101(active(X1), X2, X3)
active(fst(X)) → fst(active(X))
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(U11(X1, X2, X3)) → U11(active(X1), X2, X3)
active(snd(X)) → snd(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U31(X1, X2)) → U31(active(X1), X2)
active(U41(X1, X2)) → U41(active(X1), X2)
active(cons(X1, X2)) → cons(active(X1), X2)
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(head(X)) → head(active(X))
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(U61(X1, X2)) → U61(active(X1), X2)
active(U71(X1, X2)) → U71(active(X1), X2)
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(U81(X1, X2, X3, X4)) → U81(active(X1), X2, X3, X4)
active(U82(X1, X2)) → U82(active(X1), X2)
active(U91(X1, X2)) → U91(active(X1), X2)
active(and(X1, X2)) → and(active(X1), X2)
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
U101(mark(X1), X2, X3) → mark(U101(X1, X2, X3))
fst(mark(X)) → mark(fst(X))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
U11(mark(X1), X2, X3) → mark(U11(X1, X2, X3))
snd(mark(X)) → mark(snd(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U31(mark(X1), X2) → mark(U31(X1, X2))
U41(mark(X1), X2) → mark(U41(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
head(mark(X)) → mark(head(X))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
U61(mark(X1), X2) → mark(U61(X1, X2))
U71(mark(X1), X2) → mark(U71(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
U81(mark(X1), X2, X3, X4) → mark(U81(X1, X2, X3, X4))
U82(mark(X1), X2) → mark(U82(X1, X2))
U91(mark(X1), X2) → mark(U91(X1, X2))
and(mark(X1), X2) → mark(and(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
proper(U101(X1, X2, X3)) → U101(proper(X1), proper(X2), proper(X3))
proper(tt) → ok(tt)
proper(fst(X)) → fst(proper(X))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(U11(X1, X2, X3)) → U11(proper(X1), proper(X2), proper(X3))
proper(snd(X)) → snd(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U41(X1, X2)) → U41(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(head(X)) → head(proper(X))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(U71(X1, X2)) → U71(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(U81(X1, X2, X3, X4)) → U81(proper(X1), proper(X2), proper(X3), proper(X4))
proper(U82(X1, X2)) → U82(proper(X1), proper(X2))
proper(U91(X1, X2)) → U91(proper(X1), proper(X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatural(X)) → isNatural(proper(X))
proper(isLNat(X)) → isLNat(proper(X))
proper(isPLNat(X)) → isPLNat(proper(X))
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(0) → ok(0)
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
U101(ok(X1), ok(X2), ok(X3)) → ok(U101(X1, X2, X3))
fst(ok(X)) → ok(fst(X))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
U11(ok(X1), ok(X2), ok(X3)) → ok(U11(X1, X2, X3))
snd(ok(X)) → ok(snd(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U41(ok(X1), ok(X2)) → ok(U41(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
head(ok(X)) → ok(head(X))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
U71(ok(X1), ok(X2)) → ok(U71(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
U81(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U81(X1, X2, X3, X4))
U82(ok(X1), ok(X2)) → ok(U82(X1, X2))
U91(ok(X1), ok(X2)) → ok(U91(X1, X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatural(ok(X)) → ok(isNatural(X))
isLNat(ok(X)) → ok(isLNat(X))
isPLNat(ok(X)) → ok(isPLNat(X))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.