Termination w.r.t. Q proof of /tmp/tmpyp5jcu/LISTUTILITIES_nosorts

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

0 QTRS

↳1 DependencyPairsProof (⇔)

↳2 QDP

↳3 DependencyGraphProof (⇔)

↳4 AND

  ↳5 QDP

    ↳6 QDPOrderProof (⇔)

    ↳7 QDP

    ↳8 QDPOrderProof (⇔)

    ↳9 QDP

    ↳10 PisEmptyProof (⇔)

    ↳11 TRUE

  ↳12 QDP

    ↳13 QDPOrderProof (⇔)

    ↳14 QDP

    ↳15 QDPOrderProof (⇔)

    ↳16 QDP

    ↳17 PisEmptyProof (⇔)

    ↳18 TRUE

  ↳19 QDP

    ↳20 QDPOrderProof (⇔)

    ↳21 QDP

    ↳22 QDPOrderProof (⇔)

    ↳23 QDP

    ↳24 PisEmptyProof (⇔)

    ↳25 TRUE

  ↳26 QDP

    ↳27 QDPOrderProof (⇔)

    ↳28 QDP

    ↳29 QDPOrderProof (⇔)

    ↳30 QDP

    ↳31 PisEmptyProof (⇔)

    ↳32 TRUE

  ↳33 QDP

    ↳34 QDPOrderProof (⇔)

    ↳35 QDP

    ↳36 QDPOrderProof (⇔)

    ↳37 QDP

    ↳38 PisEmptyProof (⇔)

    ↳39 TRUE

  ↳40 QDP

    ↳41 QDPOrderProof (⇔)

    ↳42 QDP

    ↳43 QDPOrderProof (⇔)

    ↳44 QDP

    ↳45 PisEmptyProof (⇔)

    ↳46 TRUE

  ↳47 QDP

    ↳48 QDPOrderProof (⇔)

    ↳49 QDP

    ↳50 QDPOrderProof (⇔)

    ↳51 QDP

    ↳52 PisEmptyProof (⇔)

    ↳53 TRUE

  ↳54 QDP

    ↳55 QDPOrderProof (⇔)

    ↳56 QDP

    ↳57 QDPOrderProof (⇔)

    ↳58 QDP

    ↳59 PisEmptyProof (⇔)

    ↳60 TRUE

  ↳61 QDP

    ↳62 QDPOrderProof (⇔)

    ↳63 QDP

    ↳64 QDPOrderProof (⇔)

    ↳65 QDP

    ↳66 PisEmptyProof (⇔)

    ↳67 TRUE

  ↳68 QDP

    ↳69 QDPOrderProof (⇔)

    ↳70 QDP

    ↳71 QDPOrderProof (⇔)

    ↳72 QDP

    ↳73 PisEmptyProof (⇔)

    ↳74 TRUE

  ↳75 QDP

    ↳76 QDPOrderProof (⇔)

    ↳77 QDP

    ↳78 QDPOrderProof (⇔)

    ↳79 QDP

    ↳80 PisEmptyProof (⇔)

    ↳81 TRUE

  ↳82 QDP

    ↳83 QDPOrderProof (⇔)

    ↳84 QDP

    ↳85 QDPOrderProof (⇔)

    ↳86 QDP

    ↳87 QDPOrderProof (⇔)

    ↳88 QDP

    ↳89 PisEmptyProof (⇔)

    ↳90 TRUE

  ↳91 QDP

    ↳92 QDPOrderProof (⇔)

    ↳93 QDP

    ↳94 QDPOrderProof (⇔)

    ↳95 QDP

    ↳96 QDPOrderProof (⇔)

    ↳97 QDP

    ↳98 PisEmptyProof (⇔)

    ↳99 TRUE

  ↳100 QDP

    ↳101 QDPOrderProof (⇔)

    ↳102 QDP

    ↳103 QDPOrderProof (⇔)

    ↳104 QDP

    ↳105 PisEmptyProof (⇔)

    ↳106 TRUE

  ↳107 QDP

    ↳108 QDPOrderProof (⇔)

    ↳109 QDP

    ↳110 QDPOrderProof (⇔)

    ↳111 QDP

    ↳112 PisEmptyProof (⇔)

    ↳113 TRUE

  ↳114 QDP

    ↳115 QDPOrderProof (⇔)

    ↳116 QDP

    ↳117 QDPOrderProof (⇔)

    ↳118 QDP

    ↳119 QDPOrderProof (⇔)

    ↳120 QDP

    ↳121 QDPOrderProof (⇔)

    ↳122 QDP

    ↳123 QDPOrderProof (⇔)

    ↳124 QDP

    ↳125 QDPOrderProof (⇔)

    ↳126 QDP

    ↳127 PisEmptyProof (⇔)

    ↳128 TRUE

  ↳129 QDP

    ↳130 QDPOrderProof (⇔)

    ↳131 QDP

    ↳132 QDPOrderProof (⇔)

    ↳133 QDP

    ↳134 QDPOrderProof (⇔)

    ↳135 QDP

    ↳136 QDPOrderProof (⇔)

    ↳137 QDP

    ↳138 QDPOrderProof (⇔)

    ↳139 QDP

    ↳140 QDPOrderProof (⇔)

    ↳141 QDP

    ↳142 QDPOrderProof (⇔)

    ↳143 QDP

    ↳144 QDPOrderProof (⇔)

    ↳145 QDP

    ↳146 QDPOrderProof (⇔)

    ↳147 QDP

    ↳148 PisEmptyProof (⇔)

    ↳149 TRUE

  ↳150 QDP

(0) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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(U11(tt, N, X, XS)) → U12¹(splitAt(N, XS), X)
ACTIVE(U11(tt, N, X, XS)) → SPLITAT(N, XS)
ACTIVE(U12(pair(YS, ZS), X)) → PAIR(cons(X, YS), ZS)
ACTIVE(U12(pair(YS, ZS), X)) → CONS(X, YS)
ACTIVE(afterNth(N, XS)) → SND(splitAt(N, XS))
ACTIVE(afterNth(N, XS)) → SPLITAT(N, XS)
ACTIVE(natsFrom(N)) → CONS(N, natsFrom(s(N)))
ACTIVE(natsFrom(N)) → NATSFROM(s(N))
ACTIVE(natsFrom(N)) → S(N)
ACTIVE(sel(N, XS)) → HEAD(afterNth(N, XS))
ACTIVE(sel(N, XS)) → AFTERNTH(N, XS)
ACTIVE(splitAt(0, XS)) → PAIR(nil, XS)
ACTIVE(splitAt(s(N), cons(X, XS))) → U11¹(tt, N, X, XS)
ACTIVE(take(N, XS)) → FST(splitAt(N, XS))
ACTIVE(take(N, XS)) → SPLITAT(N, XS)
ACTIVE(U11(X1, X2, X3, X4)) → U11¹(active(X1), X2, X3, X4)
ACTIVE(U11(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(U12(X1, X2)) → U12¹(active(X1), X2)
ACTIVE(U12(X1, X2)) → ACTIVE(X1)
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(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(cons(X1, X2)) → CONS(active(X1), X2)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
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(snd(X)) → SND(active(X))
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(and(X1, X2)) → AND(active(X1), X2)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → FST(active(X))
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → HEAD(active(X))
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → NATSFROM(active(X))
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → S(active(X))
ACTIVE(s(X)) → ACTIVE(X)
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)
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)
U11¹(mark(X1), X2, X3, X4) → U11¹(X1, X2, X3, X4)
U12¹(mark(X1), X2) → U12¹(X1, X2)
SPLITAT(mark(X1), X2) → SPLITAT(X1, X2)
SPLITAT(X1, mark(X2)) → SPLITAT(X1, X2)
PAIR(mark(X1), X2) → PAIR(X1, X2)
PAIR(X1, mark(X2)) → PAIR(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)
AFTERNTH(mark(X1), X2) → AFTERNTH(X1, X2)
AFTERNTH(X1, mark(X2)) → AFTERNTH(X1, X2)
SND(mark(X)) → SND(X)
AND(mark(X1), X2) → AND(X1, X2)
FST(mark(X)) → FST(X)
HEAD(mark(X)) → HEAD(X)
NATSFROM(mark(X)) → NATSFROM(X)
S(mark(X)) → S(X)
SEL(mark(X1), X2) → SEL(X1, X2)
SEL(X1, mark(X2)) → SEL(X1, X2)
TAIL(mark(X)) → TAIL(X)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(X1, mark(X2)) → TAKE(X1, X2)
PROPER(U11(X1, X2, X3, X4)) → U11¹(proper(X1), proper(X2), proper(X3), proper(X4))
PROPER(U11(X1, X2, X3, X4)) → PROPER(X1)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X2)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X3)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X4)
PROPER(U12(X1, X2)) → U12¹(proper(X1), proper(X2))
PROPER(U12(X1, X2)) → PROPER(X1)
PROPER(U12(X1, X2)) → PROPER(X2)
PROPER(splitAt(X1, X2)) → SPLITAT(proper(X1), proper(X2))
PROPER(splitAt(X1, X2)) → PROPER(X1)
PROPER(splitAt(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(cons(X1, X2)) → CONS(proper(X1), proper(X2))
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(afterNth(X1, X2)) → AFTERNTH(proper(X1), proper(X2))
PROPER(afterNth(X1, X2)) → PROPER(X1)
PROPER(afterNth(X1, X2)) → PROPER(X2)
PROPER(snd(X)) → SND(proper(X))
PROPER(snd(X)) → PROPER(X)
PROPER(and(X1, X2)) → AND(proper(X1), proper(X2))
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(fst(X)) → FST(proper(X))
PROPER(fst(X)) → PROPER(X)
PROPER(head(X)) → HEAD(proper(X))
PROPER(head(X)) → PROPER(X)
PROPER(natsFrom(X)) → NATSFROM(proper(X))
PROPER(natsFrom(X)) → PROPER(X)
PROPER(s(X)) → S(proper(X))
PROPER(s(X)) → PROPER(X)
PROPER(sel(X1, X2)) → SEL(proper(X1), proper(X2))
PROPER(sel(X1, X2)) → PROPER(X1)
PROPER(sel(X1, X2)) → PROPER(X2)
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)
U11¹(ok(X1), ok(X2), ok(X3), ok(X4)) → U11¹(X1, X2, X3, X4)
U12¹(ok(X1), ok(X2)) → U12¹(X1, X2)
SPLITAT(ok(X1), ok(X2)) → SPLITAT(X1, X2)
PAIR(ok(X1), ok(X2)) → PAIR(X1, X2)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
AFTERNTH(ok(X1), ok(X2)) → AFTERNTH(X1, X2)
SND(ok(X)) → SND(X)
AND(ok(X1), ok(X2)) → AND(X1, X2)
FST(ok(X)) → FST(X)
HEAD(ok(X)) → HEAD(X)
NATSFROM(ok(X)) → NATSFROM(X)
S(ok(X)) → S(X)
SEL(ok(X1), ok(X2)) → SEL(X1, X2)
TAIL(ok(X)) → TAIL(X)
TAKE(ok(X1), ok(X2)) → TAKE(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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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 18 SCCs with 52 less nodes.

(4) Complex Obligation (AND)

(5) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = x2
fst(x1) = x1
head(x1) = head(x1)
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

TAKE₂ > [ok₁, head₁]
proper₁ > [active₁, snd₁, top] > [U11₃, U12₂] > [tt, pair₂, cons₂, s₁] > [ok₁, head₁]
proper₁ > [active₁, snd₁, top] > sel₂ > [ok₁, head₁]
proper₁ > [active₁, snd₁, top] > nil > [ok₁, head₁]
proper₁ > [active₁, snd₁, top] > take₂ > [ok₁, head₁]
proper₁ > 0 > [tt, pair₂, cons₂, s₁] > [ok₁, head₁]

Status:

TAKE₂: [2,1]
ok₁: [1]
active₁: [1]
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: [2,1]
cons₂: [1,2]
snd₁: [1]
head₁: [1]
s₁: [1]
sel₂: [2,1]
0: multiset
nil: multiset
take₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(7) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
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)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = snd(x1)
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

active₁ > [splitAt₂, and₂, proper₁] > [U11₄, cons₂] > tt > mark₁
active₁ > [splitAt₂, and₂, proper₁] > [U11₄, cons₂] > U12₂ > ok > snd₁ > mark₁
active₁ > [splitAt₂, and₂, proper₁] > afterNth₂ > ok > snd₁ > mark₁
active₁ > [splitAt₂, and₂, proper₁] > sel₂ > ok > snd₁ > mark₁
active₁ > [splitAt₂, and₂, proper₁] > 0 > pair₂ > ok > snd₁ > mark₁
active₁ > [splitAt₂, and₂, proper₁] > 0 > nil
active₁ > [splitAt₂, and₂, proper₁] > take₂ > ok > snd₁ > mark₁

Status:

TAKE₂: [2,1]
mark₁: [1]
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: multiset
splitAt₂: [1,2]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
snd₁: [1]
and₂: [2,1]
sel₂: multiset
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(9) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(10) PisEmptyProof (EQUIVALENT transformation)

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

(11) TRUE

(12) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

TAIL₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]

Status:

TAIL₁: multiset
ok₁: [1]
active₁: multiset
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: multiset
snd₁: multiset
and₁: [1]
fst₁: [1]
s₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(14) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(15) 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) = TAIL(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [TAIL₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [TAIL₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [TAIL₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [TAIL₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [TAIL₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [TAIL₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [TAIL₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [TAIL₁, mark₁]

Status:

TAIL₁: multiset
mark₁: multiset
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: multiset
fst₁: [1]
natsFrom₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(16) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(17) PisEmptyProof (EQUIVALENT transformation)

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

(18) TRUE

(19) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(20) 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)
U11(x1, x2, x3, x4) = U11(x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = x2
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[tt, proper₁] > [active₁, afterNth₂] > pair₂ > [U12₂, cons₂] > ok₁
[tt, proper₁] > [active₁, afterNth₂] > s₁ > U11₂ > [U12₂, cons₂] > ok₁
[tt, proper₁] > [active₁, afterNth₂] > s₁ > U11₂ > splitAt₁ > ok₁
[tt, proper₁] > [active₁, afterNth₂] > sel₂ > ok₁
[tt, proper₁] > [active₁, afterNth₂] > nil > ok₁
[tt, proper₁] > [active₁, afterNth₂] > take₂ > splitAt₁ > ok₁
[tt, proper₁] > 0

Status:

SEL₂: multiset
ok₁: [1]
active₁: multiset
U11₂: multiset
tt: multiset
U12₂: multiset
splitAt₁: multiset
pair₂: [1,2]
cons₂: multiset
afterNth₂: multiset
s₁: [1]
sel₂: multiset
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(21) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(22) 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)
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, x2)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, U11₄, tt, tail₁, proper₁, ok, top] > U12₂ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > [splitAt₂, afterNth₂] > pair₂ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > [splitAt₂, afterNth₂] > nil > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > cons₂ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > and₂ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > s₁ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > sel₂ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > 0 > pair₂ > [mark₁, fst₁] > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > 0 > nil > SEL₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > take₂ > [mark₁, fst₁] > SEL₂

Status:

SEL₂: [2,1]
mark₁: multiset
active₁: [1]
U11₄: [2,1,3,4]
tt: multiset
U12₂: [2,1]
splitAt₂: multiset
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: [1,2]
fst₁: multiset
s₁: [1]
sel₂: [1,2]
0: multiset
nil: multiset
tail₁: [1]
take₂: [2,1]
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(23) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(24) PisEmptyProof (EQUIVALENT transformation)

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

(25) TRUE

(26) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

S₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]

Status:

S₁: multiset
ok₁: [1]
active₁: multiset
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: multiset
snd₁: multiset
and₁: [1]
fst₁: [1]
s₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(28) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(29) 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) = S(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [S₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [S₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [S₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [S₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [S₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [S₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [S₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [S₁, mark₁]

Status:

S₁: multiset
mark₁: multiset
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: multiset
fst₁: [1]
natsFrom₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(30) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(31) PisEmptyProof (EQUIVALENT transformation)

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

(32) TRUE

(33) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

NATSFROM₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]

Status:

NATSFROM₁: multiset
ok₁: [1]
active₁: multiset
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: multiset
snd₁: multiset
and₁: [1]
fst₁: [1]
s₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(35) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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) = NATSFROM(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [NATSFROM₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [NATSFROM₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [NATSFROM₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [NATSFROM₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [NATSFROM₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [NATSFROM₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [NATSFROM₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [NATSFROM₁, mark₁]

Status:

NATSFROM₁: multiset
mark₁: multiset
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: multiset
fst₁: [1]
natsFrom₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(37) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(38) PisEmptyProof (EQUIVALENT transformation)

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

(39) TRUE

(40) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

HEAD₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]

Status:

HEAD₁: multiset
ok₁: [1]
active₁: multiset
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: multiset
snd₁: multiset
and₁: [1]
fst₁: [1]
s₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(42) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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) = HEAD(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [HEAD₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [HEAD₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [HEAD₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [HEAD₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [HEAD₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [HEAD₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [HEAD₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [HEAD₁, mark₁]

Status:

HEAD₁: multiset
mark₁: multiset
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: multiset
fst₁: [1]
natsFrom₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(44) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(45) PisEmptyProof (EQUIVALENT transformation)

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

(46) TRUE

(47) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

FST₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]

Status:

FST₁: multiset
ok₁: [1]
active₁: multiset
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: multiset
snd₁: multiset
and₁: [1]
fst₁: [1]
s₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(49) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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) = FST(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [FST₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [FST₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [FST₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [FST₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [FST₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [FST₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [FST₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [FST₁, mark₁]

Status:

FST₁: multiset
mark₁: multiset
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: multiset
fst₁: [1]
natsFrom₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(51) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(52) PisEmptyProof (EQUIVALENT transformation)

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

(53) TRUE

(54) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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) = AND(x2)
ok(x1) = ok(x1)
mark(x1) = mark
active(x1) = active(x1)
U11(x1, x2, x3, x4) = x1
tt = tt
U12(x1, x2) = x1
splitAt(x1, x2) = x2
pair(x1, x2) = x1
cons(x1, x2) = x2
afterNth(x1, x2) = x1
snd(x1) = x1
and(x1, x2) = x2
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = x1
sel(x1, x2) = x1
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x1
proper(x1) = proper
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

AND₁ > [mark, active₁, tt]
proper > 0 > ok₁ > [mark, active₁, tt]
proper > 0 > nil > [mark, active₁, tt]
top > [mark, active₁, tt]

Status:

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

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(56) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

AND₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > [U12₂, cons₂] > U11₄ > mark₁
[active₁, top] > [tt, take₂, proper₁] > [U12₂, cons₂] > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > splitAt₂ > U11₄ > mark₁
[active₁, top] > [tt, take₂, proper₁] > splitAt₂ > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > and₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > s₁ > mark₁
[active₁, top] > [tt, take₂, proper₁] > sel₂ > afterNth₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > 0 > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > nil > mark₁

Status:

AND₂: [2,1]
mark₁: [1]
active₁: multiset
U11₄: [1,2,3,4]
tt: multiset
U12₂: multiset
splitAt₂: multiset
pair₂: multiset
cons₂: multiset
afterNth₂: [2,1]
and₂: [2,1]
s₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(58) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(59) PisEmptyProof (EQUIVALENT transformation)

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

(60) TRUE

(61) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

SND₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
proper₁ > and₁ > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > [tt, pair₂, cons₂] > U12₂ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > snd₁ > [ok₁, s₁, 0]
top > [active₁, U11₃, nil] > fst₁ > [ok₁, s₁, 0]

Status:

SND₁: multiset
ok₁: [1]
active₁: multiset
U11₃: multiset
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: multiset
snd₁: multiset
and₁: [1]
fst₁: [1]
s₁: [1]
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(63) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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) = SND(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [SND₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [SND₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [SND₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [SND₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [SND₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [SND₁, mark₁]
0 > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > U11₄ > [U12₂, pair₂] > cons₂ > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > tt > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > afterNth₂ > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > and₂ > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > fst₁ > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > natsFrom₁ > cons₂ > [SND₁, mark₁]
top > [nil, proper₁] > [active₁, splitAt₂, sel₂] > take₂ > [SND₁, mark₁]

Status:

SND₁: multiset
mark₁: multiset
active₁: [1]
U11₄: multiset
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: multiset
fst₁: [1]
natsFrom₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(65) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(66) PisEmptyProof (EQUIVALENT transformation)

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

(67) TRUE

(68) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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) = AFTERNTH(x1, x2)
mark(x1) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = x2
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[tt, proper₁] > [active₁, afterNth₂] > pair₂ > [U12₂, cons₂] > ok₁
[tt, proper₁] > [active₁, afterNth₂] > s₁ > U11₂ > [U12₂, cons₂] > ok₁
[tt, proper₁] > [active₁, afterNth₂] > s₁ > U11₂ > splitAt₁ > ok₁
[tt, proper₁] > [active₁, afterNth₂] > sel₂ > ok₁
[tt, proper₁] > [active₁, afterNth₂] > nil > ok₁
[tt, proper₁] > [active₁, afterNth₂] > take₂ > splitAt₁ > ok₁
[tt, proper₁] > 0

Status:

AFTERNTH₂: multiset
ok₁: [1]
active₁: multiset
U11₂: multiset
tt: multiset
U12₂: multiset
splitAt₁: multiset
pair₂: [1,2]
cons₂: multiset
afterNth₂: multiset
s₁: [1]
sel₂: multiset
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(70) 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)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, U11₄, tt, tail₁, proper₁, ok, top] > U12₂ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > [splitAt₂, afterNth₂] > pair₂ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > [splitAt₂, afterNth₂] > nil > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > cons₂ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > and₂ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > s₁ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > sel₂ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > 0 > pair₂ > [mark₁, fst₁] > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > 0 > nil > AFTERNTH₂
[active₁, U11₄, tt, tail₁, proper₁, ok, top] > take₂ > [mark₁, fst₁] > AFTERNTH₂

Status:

AFTERNTH₂: [2,1]
mark₁: multiset
active₁: [1]
U11₄: [2,1,3,4]
tt: multiset
U12₂: [2,1]
splitAt₂: multiset
pair₂: multiset
cons₂: multiset
afterNth₂: multiset
and₂: [1,2]
fst₁: multiset
s₁: [1]
sel₂: [1,2]
0: multiset
nil: multiset
tail₁: [1]
take₂: [2,1]
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(72) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(73) PisEmptyProof (EQUIVALENT transformation)

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

(74) TRUE

(75) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

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)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x2)
fst(x1) = x1
head(x1) = head(x1)
natsFrom(x1) = x1
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

CONS₂ > ok₁
proper₁ > and₁ > [active₁, U11₄, tt, U12₂, afterNth₂] > [splitAt₂, take₂] > ok₁
proper₁ > and₁ > [active₁, U11₄, tt, U12₂, afterNth₂] > [pair₂, cons₂] > ok₁
proper₁ > and₁ > [active₁, U11₄, tt, U12₂, afterNth₂] > head₁ > ok₁
proper₁ > and₁ > [active₁, U11₄, tt, U12₂, afterNth₂] > sel₂ > ok₁
proper₁ > and₁ > [active₁, U11₄, tt, U12₂, afterNth₂] > nil > ok₁
proper₁ > and₁ > [active₁, U11₄, tt, U12₂, afterNth₂] > tail₁ > ok₁
proper₁ > 0 > ok₁
top > ok₁

Status:

CONS₂: multiset
ok₁: [1]
active₁: [1]
U11₄: [2,1,3,4]
tt: multiset
U12₂: [2,1]
splitAt₂: [1,2]
pair₂: multiset
cons₂: multiset
afterNth₂: [2,1]
and₁: [1]
head₁: [1]
sel₂: multiset
0: multiset
nil: multiset
tail₁: [1]
take₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(77) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, tt] > [0, nil, ok] > [U11₄, U12₂, splitAt₂, pair₂, cons₂, afterNth₂, and₂, s₁, sel₂, take₂, proper₁] > mark₁ > top

Status:

CONS₂: [2,1]
mark₁: multiset
active₁: [1]
U11₄: [1,3,4,2]
tt: multiset
U12₂: [1,2]
splitAt₂: [2,1]
pair₂: [2,1]
cons₂: [1,2]
afterNth₂: [1,2]
and₂: [1,2]
s₁: [1]
sel₂: [1,2]
0: multiset
nil: multiset
take₂: [1,2]
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(79) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(80) PisEmptyProof (EQUIVALENT transformation)

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

(81) TRUE

(82) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

PAIR(X1, mark(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(x2)
mark(x1) = mark(x1)
ok(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = snd(x1)
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = head(x1)
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, tt, U12₂, proper₁] > U11₄ > [splitAt₂, pair₂, 0] > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > cons₂ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > afterNth₂ > [splitAt₂, pair₂, 0] > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > afterNth₂ > snd₁ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > and₂ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > head₁ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > s₁ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > sel₂ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > nil
[active₁, tt, U12₂, proper₁] > tail₁ > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > take₂ > [splitAt₂, pair₂, 0] > [PAIR₁, mark₁]
[active₁, tt, U12₂, proper₁] > take₂ > fst₁ > [PAIR₁, mark₁]

Status:

PAIR₁: multiset
mark₁: multiset
active₁: [1]
U11₄: [2,3,4,1]
tt: multiset
U12₂: [2,1]
splitAt₂: [1,2]
pair₂: multiset
cons₂: [2,1]
afterNth₂: [2,1]
snd₁: [1]
and₂: multiset
fst₁: multiset
head₁: [1]
s₁: [1]
sel₂: [2,1]
0: multiset
nil: multiset
tail₁: [1]
take₂: [1,2]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(84) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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(x2)
mark(x1) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x2)
snd(x1) = snd(x1)
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, tt, afterNth₁, proper₁] > U12₂ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > [pair₂, cons₂] > U11₃ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > snd₁ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > and₂ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > s₁ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > [0, nil]
[active₁, tt, afterNth₁, proper₁] > take₂ > [ok₁, tail₁]

Status:

PAIR₁: multiset
ok₁: [1]
active₁: [1]
U11₃: [3,2,1]
tt: multiset
U12₂: [1,2]
pair₂: [1,2]
cons₂: [2,1]
afterNth₁: [1]
snd₁: [1]
and₂: [2,1]
s₁: multiset
0: multiset
nil: multiset
tail₁: [1]
take₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(86) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(87) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

PAIR₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > [U12₂, cons₂] > U11₄ > mark₁
[active₁, top] > [tt, take₂, proper₁] > [U12₂, cons₂] > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > splitAt₂ > U11₄ > mark₁
[active₁, top] > [tt, take₂, proper₁] > splitAt₂ > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > and₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > s₁ > mark₁
[active₁, top] > [tt, take₂, proper₁] > sel₂ > afterNth₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > 0 > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > nil > mark₁

Status:

PAIR₂: [2,1]
mark₁: [1]
active₁: multiset
U11₄: [1,2,3,4]
tt: multiset
U12₂: multiset
splitAt₂: multiset
pair₂: multiset
cons₂: multiset
afterNth₂: [2,1]
and₂: [2,1]
s₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(88) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(89) PisEmptyProof (EQUIVALENT transformation)

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

(90) TRUE

(91) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) 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)
ok(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = snd(x1)
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = head(x1)
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, tt, U12₂, proper₁] > U11₄ > [splitAt₂, pair₂, 0] > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > cons₂ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > afterNth₂ > [splitAt₂, pair₂, 0] > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > afterNth₂ > snd₁ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > and₂ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > head₁ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > s₁ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > sel₂ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > nil
[active₁, tt, U12₂, proper₁] > tail₁ > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > take₂ > [splitAt₂, pair₂, 0] > [SPLITAT₁, mark₁]
[active₁, tt, U12₂, proper₁] > take₂ > fst₁ > [SPLITAT₁, mark₁]

Status:

SPLITAT₁: multiset
mark₁: multiset
active₁: [1]
U11₄: [2,3,4,1]
tt: multiset
U12₂: [2,1]
splitAt₂: [1,2]
pair₂: multiset
cons₂: [2,1]
afterNth₂: [2,1]
snd₁: [1]
and₂: multiset
fst₁: multiset
head₁: [1]
s₁: [1]
sel₂: [2,1]
0: multiset
nil: multiset
tail₁: [1]
take₂: [1,2]
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(93) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(94) 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(x2)
mark(x1) = x1
ok(x1) = ok(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x2)
snd(x1) = snd(x1)
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, tt, afterNth₁, proper₁] > U12₂ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > [pair₂, cons₂] > U11₃ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > snd₁ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > and₂ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > s₁ > [ok₁, tail₁]
[active₁, tt, afterNth₁, proper₁] > [0, nil]
[active₁, tt, afterNth₁, proper₁] > take₂ > [ok₁, tail₁]

Status:

SPLITAT₁: multiset
ok₁: [1]
active₁: [1]
U11₃: [3,2,1]
tt: multiset
U12₂: [1,2]
pair₂: [1,2]
cons₂: [2,1]
afterNth₁: [1]
snd₁: [1]
and₂: [2,1]
s₁: multiset
0: multiset
nil: multiset
tail₁: [1]
take₂: [1,2]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(95) 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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(96) 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)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

SPLITAT₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > [U12₂, cons₂] > U11₄ > mark₁
[active₁, top] > [tt, take₂, proper₁] > [U12₂, cons₂] > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > splitAt₂ > U11₄ > mark₁
[active₁, top] > [tt, take₂, proper₁] > splitAt₂ > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > and₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > s₁ > mark₁
[active₁, top] > [tt, take₂, proper₁] > sel₂ > afterNth₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > 0 > pair₂ > mark₁
[active₁, top] > [tt, take₂, proper₁] > nil > mark₁

Status:

SPLITAT₂: [2,1]
mark₁: [1]
active₁: multiset
U11₄: [1,2,3,4]
tt: multiset
U12₂: multiset
splitAt₂: multiset
pair₂: multiset
cons₂: multiset
afterNth₂: [2,1]
and₂: [2,1]
s₁: multiset
sel₂: [2,1]
0: multiset
nil: multiset
take₂: multiset
proper₁: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(97) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(98) PisEmptyProof (EQUIVALENT transformation)

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

(99) TRUE

(100) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(101) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U12¹(x1, x2) = U12¹(x2)
ok(x1) = ok(x1)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = snd(x1)
and(x1, x2) = and(x2)
fst(x1) = x1
head(x1) = head(x1)
natsFrom(x1) = x1
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

top > proper₁ > [active₁, snd₁, head₁, take₂] > [U11₃, pair₂, cons₂, 0, nil] > U12₂ > [U12^1₁, ok₁, and₁]
top > proper₁ > [active₁, snd₁, head₁, take₂] > tt > U12₂ > [U12^1₁, ok₁, and₁]
top > proper₁ > [active₁, snd₁, head₁, take₂] > sel₂ > [U12^1₁, ok₁, and₁]
top > proper₁ > [active₁, snd₁, head₁, take₂] > tail₁ > [U12^1₁, ok₁, and₁]

Status:

U12^1₁: multiset
ok₁: [1]
active₁: [1]
U11₃: [3,2,1]
tt: multiset
U12₂: multiset
pair₂: [2,1]
cons₂: [2,1]
snd₁: [1]
and₁: [1]
head₁: [1]
sel₂: [2,1]
0: multiset
nil: multiset
tail₁: [1]
take₂: [2,1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(102) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(103) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U12¹(x1, x2) = U12¹(x1, x2)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

U12^1₂ > [mark₁, s₁]
[proper₁, ok] > 0 > [active₁, tt, pair₂, cons₂, and₂, natsFrom₁, take₂] > [U11₄, splitAt₂, afterNth₂] > U12₂ > [mark₁, s₁]
[proper₁, ok] > 0 > [active₁, tt, pair₂, cons₂, and₂, natsFrom₁, take₂] > sel₂ > [mark₁, s₁]
[proper₁, ok] > 0 > nil > [mark₁, s₁]
[proper₁, ok] > top > [active₁, tt, pair₂, cons₂, and₂, natsFrom₁, take₂] > [U11₄, splitAt₂, afterNth₂] > U12₂ > [mark₁, s₁]
[proper₁, ok] > top > [active₁, tt, pair₂, cons₂, and₂, natsFrom₁, take₂] > sel₂ > [mark₁, s₁]

Status:

U12^1₂: [1,2]
mark₁: [1]
active₁: [1]
U11₄: [1,4,3,2]
tt: multiset
U12₂: multiset
splitAt₂: multiset
pair₂: [2,1]
cons₂: [1,2]
afterNth₂: [2,1]
and₂: [2,1]
natsFrom₁: [1]
s₁: [1]
sel₂: multiset
0: multiset
nil: multiset
take₂: [1,2]
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(104) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(105) PisEmptyProof (EQUIVALENT transformation)

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

(106) TRUE

(107) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(108) 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), ok(X4)) → U11¹(X1, X2, X3, X4)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U11¹(x1, x2, x3, x4) = U11¹(x1, x2, x3)
ok(x1) = ok(x1)
mark(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = x2
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = x2
snd(x1) = x1
and(x1, x2) = x2
fst(x1) = x1
head(x1) = head(x1)
natsFrom(x1) = natsFrom(x1)
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = x2
proper(x1) = proper(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

tt > [U12₂, pair₂, 0] > [ok₁, s₁]
top > [active₁, U11₂, cons₂, natsFrom₁, proper₁] > [U12₂, pair₂, 0] > [ok₁, s₁]
top > [active₁, U11₂, cons₂, natsFrom₁, proper₁] > head₁ > [ok₁, s₁]
top > [active₁, U11₂, cons₂, natsFrom₁, proper₁] > sel₂ > [ok₁, s₁]
top > [active₁, U11₂, cons₂, natsFrom₁, proper₁] > nil > [ok₁, s₁]

Status:

U11^1₃: [1,2,3]
ok₁: [1]
active₁: [1]
U11₂: [2,1]
tt: multiset
U12₂: multiset
pair₂: multiset
cons₂: [1,2]
head₁: multiset
natsFrom₁: [1]
s₁: [1]
sel₂: multiset
0: multiset
nil: multiset
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(109) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(110) 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, X4) → U11¹(X1, X2, X3, X4)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
U11¹(x1, x2, x3, x4) = U11¹(x1)
mark(x1) = mark(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
tail(x1) = x1
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

U11^1₁ > mark₁
[active₁, U11₄, tt, U12₂, pair₂, cons₂, and₂, nil, proper₁, ok] > afterNth₂ > splitAt₂ > mark₁
[active₁, U11₄, tt, U12₂, pair₂, cons₂, and₂, nil, proper₁, ok] > natsFrom₁ > mark₁
[active₁, U11₄, tt, U12₂, pair₂, cons₂, and₂, nil, proper₁, ok] > sel₂ > mark₁
[active₁, U11₄, tt, U12₂, pair₂, cons₂, and₂, nil, proper₁, ok] > 0 > mark₁
[active₁, U11₄, tt, U12₂, pair₂, cons₂, and₂, nil, proper₁, ok] > take₂ > splitAt₂ > mark₁
[active₁, U11₄, tt, U12₂, pair₂, cons₂, and₂, nil, proper₁, ok] > top > mark₁

Status:

U11^1₁: multiset
mark₁: [1]
active₁: [1]
U11₄: [2,1,4,3]
tt: multiset
U12₂: [1,2]
splitAt₂: multiset
pair₂: [2,1]
cons₂: [1,2]
afterNth₂: multiset
and₂: [2,1]
natsFrom₁: multiset
sel₂: multiset
0: multiset
nil: multiset
take₂: multiset
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(111) Obligation:

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

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(112) PisEmptyProof (EQUIVALENT transformation)

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

(113) TRUE

(114) Obligation:

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

PROPER(U11(X1, X2, X3, X4)) → PROPER(X2)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X1)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X3)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X4)
PROPER(U12(X1, X2)) → PROPER(X1)
PROPER(U12(X1, X2)) → PROPER(X2)
PROPER(splitAt(X1, X2)) → PROPER(X1)
PROPER(splitAt(X1, X2)) → PROPER(X2)
PROPER(pair(X1, X2)) → PROPER(X1)
PROPER(pair(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(afterNth(X1, X2)) → PROPER(X1)
PROPER(afterNth(X1, X2)) → PROPER(X2)
PROPER(snd(X)) → PROPER(X)
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(fst(X)) → PROPER(X)
PROPER(head(X)) → PROPER(X)
PROPER(natsFrom(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(sel(X1, X2)) → PROPER(X1)
PROPER(sel(X1, X2)) → PROPER(X2)
PROPER(tail(X)) → PROPER(X)
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(115) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(U11(X1, X2, X3, X4)) → PROPER(X2)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X1)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X3)
PROPER(U11(X1, X2, X3, X4)) → PROPER(X4)
PROPER(U12(X1, X2)) → PROPER(X1)
PROPER(U12(X1, X2)) → PROPER(X2)
PROPER(splitAt(X1, X2)) → PROPER(X1)
PROPER(splitAt(X1, X2)) → PROPER(X2)
PROPER(pair(X1, X2)) → PROPER(X1)
PROPER(pair(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(afterNth(X1, X2)) → PROPER(X1)
PROPER(afterNth(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(s(X)) → PROPER(X)
PROPER(sel(X1, X2)) → PROPER(X1)
PROPER(sel(X1, X2)) → PROPER(X2)
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(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)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s(x1)
sel(x1, x2) = sel(x1, x2)
tail(x1) = x1
take(x1, x2) = take(x1, x2)
active(x1) = active(x1)
tt = tt
mark(x1) = mark
0 = 0
nil = nil
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

nil > [U12₂, pair₂, active₁, mark, ok] > [PROPER₁, U11₄, splitAt₂] > tt > cons₂
nil > [U12₂, pair₂, active₁, mark, ok] > afterNth₂ > cons₂
nil > [U12₂, pair₂, active₁, mark, ok] > and₂ > cons₂
nil > [U12₂, pair₂, active₁, mark, ok] > s₁ > cons₂
nil > [U12₂, pair₂, active₁, mark, ok] > sel₂ > cons₂
nil > [U12₂, pair₂, active₁, mark, ok] > take₂ > cons₂
[proper₁, top] > [U12₂, pair₂, active₁, mark, ok] > [PROPER₁, U11₄, splitAt₂] > tt > cons₂
[proper₁, top] > [U12₂, pair₂, active₁, mark, ok] > afterNth₂ > cons₂
[proper₁, top] > [U12₂, pair₂, active₁, mark, ok] > and₂ > cons₂
[proper₁, top] > [U12₂, pair₂, active₁, mark, ok] > s₁ > cons₂
[proper₁, top] > [U12₂, pair₂, active₁, mark, ok] > sel₂ > cons₂
[proper₁, top] > [U12₂, pair₂, active₁, mark, ok] > take₂ > cons₂
[proper₁, top] > 0 > cons₂

Status:

PROPER₁: multiset
U11₄: multiset
U12₂: [2,1]
splitAt₂: multiset
pair₂: [2,1]
cons₂: multiset
afterNth₂: multiset
and₂: multiset
s₁: multiset
sel₂: multiset
take₂: multiset
active₁: [1]
tt: multiset
mark: []
0: multiset
nil: multiset
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(116) Obligation:

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

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(117) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(natsFrom(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)
snd(x1) = x1
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
tail(x1) = x1
active(x1) = x1
U11(x1, x2, x3, x4) = x1
tt = tt
mark(x1) = mark
U12(x1, x2) = U12(x1)
splitAt(x1, x2) = splitAt(x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons
afterNth(x1, x2) = afterNth(x1, x2)
and(x1, x2) = and(x1, x2)
s(x1) = s(x1)
sel(x1, x2) = sel
0 = 0
nil = nil
take(x1, x2) = take(x1)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[natsFrom₁, U12₁, and₂, proper₁] > PROPER₁
[natsFrom₁, U12₁, and₂, proper₁] > tt > [mark, splitAt₁]
[natsFrom₁, U12₁, and₂, proper₁] > cons > [mark, splitAt₁]
[natsFrom₁, U12₁, and₂, proper₁] > [afterNth₂, sel] > [mark, splitAt₁]
[natsFrom₁, U12₁, and₂, proper₁] > s₁ > [mark, splitAt₁]
[natsFrom₁, U12₁, and₂, proper₁] > 0 > pair₂ > [mark, splitAt₁]
[natsFrom₁, U12₁, and₂, proper₁] > 0 > nil
[natsFrom₁, U12₁, and₂, proper₁] > take₁ > [mark, splitAt₁]

Status:

PROPER₁: multiset
natsFrom₁: [1]
tt: multiset
mark: multiset
U12₁: [1]
splitAt₁: multiset
pair₂: [2,1]
cons: []
afterNth₂: [1,2]
and₂: [1,2]
s₁: [1]
sel: []
0: multiset
nil: multiset
take₁: [1]
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(118) Obligation:

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

PROPER(snd(X)) → PROPER(X)
PROPER(fst(X)) → PROPER(X)
PROPER(head(X)) → PROPER(X)
PROPER(tail(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(119) 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)
snd(x1) = x1
fst(x1) = x1
head(x1) = head(x1)
tail(x1) = x1
active(x1) = x1
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
mark(x1) = mark
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
and(x1, x2) = and(x1, x2)
natsFrom(x1) = x1
s(x1) = s
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
take(x1, x2) = take
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[PROPER₁, head₁] > mark
[U11₄, cons₂] > tt > splitAt > mark
[U11₄, cons₂] > U12₂ > pair₂ > mark
and₂ > mark
s > mark
sel₂ > afterNth₂ > mark
0 > pair₂ > mark
0 > nil > mark
take > mark
top > mark

Status:

PROPER₁: multiset
head₁: [1]
U11₄: [1,3,4,2]
tt: multiset
mark: []
U12₂: [2,1]
splitAt: []
pair₂: multiset
cons₂: [2,1]
afterNth₂: [1,2]
and₂: [1,2]
s: []
sel₂: [1,2]
0: multiset
nil: multiset
take: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(120) Obligation:

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

PROPER(snd(X)) → PROPER(X)
PROPER(fst(X)) → PROPER(X)
PROPER(tail(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(121) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROPER(snd(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)
snd(x1) = snd(x1)
fst(x1) = x1
tail(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x2, x4)
tt = tt
mark(x1) = mark
U12(x1, x2) = x1
splitAt(x1, x2) = x1
pair(x1, x2) = pair
cons(x1, x2) = cons
afterNth(x1, x2) = afterNth
and(x1, x2) = and(x1, x2)
head(x1) = head
natsFrom(x1) = natsFrom
s(x1) = x1
sel(x1, x2) = x1
0 = 0
nil = nil
take(x1, x2) = x1
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

PROPER₁ > mark
cons > tt > [pair, nil, ok] > [U11₂, proper₁] > [active₁, and₂] > snd₁ > mark
afterNth > [pair, nil, ok] > [U11₂, proper₁] > [active₁, and₂] > snd₁ > mark
head > [pair, nil, ok] > [U11₂, proper₁] > [active₁, and₂] > snd₁ > mark
natsFrom > [pair, nil, ok] > [U11₂, proper₁] > [active₁, and₂] > snd₁ > mark
0 > [pair, nil, ok] > [U11₂, proper₁] > [active₁, and₂] > snd₁ > mark
top > [U11₂, proper₁] > [active₁, and₂] > snd₁ > mark

Status:

PROPER₁: [1]
snd₁: multiset
active₁: [1]
U11₂: [1,2]
tt: multiset
mark: multiset
pair: []
cons: multiset
afterNth: multiset
and₂: [2,1]
head: multiset
natsFrom: multiset
0: multiset
nil: multiset
proper₁: [1]
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(122) Obligation:

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

PROPER(fst(X)) → PROPER(X)
PROPER(tail(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

PROPER(fst(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)
tail(x1) = x1
active(x1) = x1
U11(x1, x2, x3, x4) = U11(x2)
tt = tt
mark(x1) = mark
U12(x1, x2) = U12(x1, x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = x1
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = snd
and(x1, x2) = and(x1, x2)
head(x1) = head(x1)
natsFrom(x1) = natsFrom(x1)
s(x1) = s
sel(x1, x2) = sel
0 = 0
nil = nil
take(x1, x2) = take
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

PROPER₁ > [fst₁, mark, and₂, sel]
U11₁ > U12₂ > [fst₁, mark, and₂, sel]
U11₁ > splitAt₂ > [fst₁, mark, and₂, sel]
tt > U12₂ > [fst₁, mark, and₂, sel]
tt > splitAt₂ > [fst₁, mark, and₂, sel]
cons₂ > [fst₁, mark, and₂, sel]
afterNth₂ > splitAt₂ > [fst₁, mark, and₂, sel]
afterNth₂ > snd > [fst₁, mark, and₂, sel]
head₁ > [fst₁, mark, and₂, sel]
natsFrom₁ > [fst₁, mark, and₂, sel]
s > [fst₁, mark, and₂, sel]
0 > [fst₁, mark, and₂, sel]
nil > [fst₁, mark, and₂, sel]
take > splitAt₂ > [fst₁, mark, and₂, sel]
top > [fst₁, mark, and₂, sel]

Status:

PROPER₁: multiset
fst₁: [1]
U11₁: multiset
tt: multiset
mark: multiset
U12₂: [2,1]
splitAt₂: [2,1]
cons₂: [2,1]
afterNth₂: multiset
snd: []
and₂: [2,1]
head₁: [1]
natsFrom₁: multiset
s: []
sel: multiset
0: multiset
nil: multiset
take: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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:

PROPER(tail(X)) → PROPER(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

PROPER(tail(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)
tail(x1) = tail(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
tt = tt
mark(x1) = mark
U12(x1, x2) = U12(x2)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair
cons(x1, x2) = cons(x2)
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = fst(x1)
head(x1) = head
natsFrom(x1) = natsFrom
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
take(x1, x2) = take(x1, x2)
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > tail₁ > PROPER₁
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > U11₄
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > tt
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > afterNth₂
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > and₂
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > fst₁
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > sel₂
pair > [U12₁, cons₁, proper₁] > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > top
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > tail₁ > PROPER₁
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > U11₄
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > tt
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > afterNth₂
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > and₂
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > fst₁
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > sel₂
0 > [active₁, mark, splitAt₂, head, natsFrom, nil, take₂] > top

Status:

PROPER₁: multiset
tail₁: [1]
active₁: [1]
U11₄: multiset
tt: multiset
mark: []
U12₁: multiset
splitAt₂: [2,1]
pair: multiset
cons₁: multiset
afterNth₂: multiset
and₂: multiset
fst₁: multiset
head: []
natsFrom: []
sel₂: multiset
0: multiset
nil: multiset
take₂: [2,1]
proper₁: multiset
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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:

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(U11(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X2)
ACTIVE(pair(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → ACTIVE(X2)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X2)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(sel(X1, X2)) → ACTIVE(X1)
ACTIVE(sel(X1, X2)) → ACTIVE(X2)
ACTIVE(tail(X)) → ACTIVE(X)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X2)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

ACTIVE(U11(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X1)
ACTIVE(splitAt(X1, X2)) → ACTIVE(X2)
ACTIVE(pair(X1, X2)) → ACTIVE(X1)
ACTIVE(pair(X1, X2)) → ACTIVE(X2)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X1)
ACTIVE(afterNth(X1, X2)) → ACTIVE(X2)
ACTIVE(sel(X1, X2)) → ACTIVE(X1)
ACTIVE(sel(X1, X2)) → ACTIVE(X2)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(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) = ACTIVE(x1)
U12(x1, x2) = x1
U11(x1, x2, x3, x4) = U11(x1, x2, x3, x4)
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = x1
afterNth(x1, x2) = afterNth(x1, x2)
snd(x1) = x1
and(x1, x2) = x1
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = x1
sel(x1, x2) = sel(x1, x2)
tail(x1) = x1
take(x1, x2) = take(x1, x2)
active(x1) = active(x1)
tt = tt
mark(x1) = mark
0 = 0
nil = nil
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

ACTIVE₁ > U11₄
proper₁ > [sel₂, active₁] > mark > [splitAt₂, tt] > pair₂ > U11₄
proper₁ > [sel₂, active₁] > mark > afterNth₂ > U11₄
proper₁ > [sel₂, active₁] > mark > take₂ > U11₄
proper₁ > 0 > pair₂ > U11₄
proper₁ > nil > U11₄
top > [sel₂, active₁] > mark > [splitAt₂, tt] > pair₂ > U11₄
top > [sel₂, active₁] > mark > afterNth₂ > U11₄
top > [sel₂, active₁] > mark > take₂ > U11₄

Status:

ACTIVE₁: [1]
U11₄: [2,3,4,1]
splitAt₂: [1,2]
pair₂: multiset
afterNth₂: [2,1]
sel₂: multiset
take₂: multiset
active₁: multiset
tt: multiset
mark: []
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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:

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

ACTIVE(cons(X1, X2)) → ACTIVE(X1)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = ACTIVE(x1)
U12(x1, x2) = x1
cons(x1, x2) = cons(x1)
snd(x1) = x1
and(x1, x2) = x1
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = x1
tail(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11
tt = tt
mark(x1) = mark
splitAt(x1, x2) = splitAt
pair(x1, x2) = x2
afterNth(x1, x2) = afterNth(x1, x2)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
take(x1, x2) = take
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

ACTIVE₁ > [mark, nil]
U11 > splitAt > [active₁, afterNth₂] > cons₁ > [mark, nil]
U11 > splitAt > [active₁, afterNth₂] > sel₂ > [mark, nil]
U11 > splitAt > [active₁, afterNth₂] > take > [mark, nil]
tt > splitAt > [active₁, afterNth₂] > cons₁ > [mark, nil]
tt > splitAt > [active₁, afterNth₂] > sel₂ > [mark, nil]
tt > splitAt > [active₁, afterNth₂] > take > [mark, nil]
0 > [mark, nil]
top > [active₁, afterNth₂] > cons₁ > [mark, nil]
top > [active₁, afterNth₂] > sel₂ > [mark, nil]
top > [active₁, afterNth₂] > take > [mark, nil]

Status:

ACTIVE₁: [1]
cons₁: [1]
active₁: [1]
U11: multiset
tt: multiset
mark: []
splitAt: multiset
afterNth₂: [2,1]
sel₂: multiset
0: multiset
nil: multiset
take: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(133) Obligation:

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

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(and(X1, X2)) → ACTIVE(X1)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = x1
U12(x1, x2) = x1
snd(x1) = x1
and(x1, x2) = and(x1, x2)
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = x1
s(x1) = x1
tail(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x1, x4)
tt = tt
mark(x1) = mark
splitAt(x1, x2) = splitAt
pair(x1, x2) = pair
cons(x1, x2) = cons
afterNth(x1, x2) = afterNth(x1, x2)
sel(x1, x2) = sel(x1, x2)
0 = 0
nil = nil
take(x1, x2) = take(x1)
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[active₁, take₁, proper₁] > [U11₂, mark, splitAt, pair, cons] > and₂ > [sel₂, ok]
[active₁, take₁, proper₁] > [U11₂, mark, splitAt, pair, cons] > tt
[active₁, take₁, proper₁] > [U11₂, mark, splitAt, pair, cons] > afterNth₂ > [sel₂, ok]
[active₁, take₁, proper₁] > [U11₂, mark, splitAt, pair, cons] > [0, nil] > [sel₂, ok]
[active₁, take₁, proper₁] > [U11₂, mark, splitAt, pair, cons] > top

Status:

and₂: multiset
active₁: multiset
U11₂: multiset
tt: multiset
mark: []
splitAt: []
pair: []
cons: []
afterNth₂: multiset
sel₂: multiset
0: multiset
nil: multiset
take₁: multiset
proper₁: multiset
ok: []
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(135) Obligation:

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

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(136) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVE(natsFrom(X)) → ACTIVE(X)
ACTIVE(s(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)
U12(x1, x2) = x1
snd(x1) = x1
fst(x1) = x1
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = s(x1)
tail(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = x2
tt = tt
mark(x1) = mark
splitAt(x1, x2) = x1
pair(x1, x2) = x1
cons(x1, x2) = x1
afterNth(x1, x2) = afterNth(x1, x2)
and(x1, x2) = and(x1, x2)
sel(x1, x2) = x2
0 = 0
nil = nil
take(x1, x2) = x2
proper(x1) = proper(x1)
ok(x1) = ok(x1)
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

tt > [natsFrom₁, ok₁] > [ACTIVE₁, mark, 0]
nil > [natsFrom₁, ok₁] > [ACTIVE₁, mark, 0]
proper₁ > [s₁, active₁] > afterNth₂ > [natsFrom₁, ok₁] > [ACTIVE₁, mark, 0]
proper₁ > [s₁, active₁] > and₂ > [natsFrom₁, ok₁] > [ACTIVE₁, mark, 0]
top > [ACTIVE₁, mark, 0]

Status:

ACTIVE₁: multiset
natsFrom₁: [1]
s₁: [1]
active₁: [1]
tt: multiset
mark: multiset
afterNth₂: [2,1]
and₂: [1,2]
0: multiset
nil: multiset
proper₁: [1]
ok₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(137) Obligation:

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

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(snd(X)) → ACTIVE(X)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(138) 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)
U12(x1, x2) = x1
snd(x1) = snd(x1)
fst(x1) = x1
head(x1) = x1
tail(x1) = x1
active(x1) = active(x1)
U11(x1, x2, x3, x4) = x1
tt = tt
mark(x1) = mark
splitAt(x1, x2) = splitAt(x2)
pair(x1, x2) = x2
cons(x1, x2) = cons(x1)
afterNth(x1, x2) = afterNth
and(x1, x2) = x2
natsFrom(x1) = natsFrom(x1)
s(x1) = s(x1)
sel(x1, x2) = x2
0 = 0
nil = nil
take(x1, x2) = x1
proper(x1) = x1
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

ACTIVE₁ > [mark, cons₁, 0]
tt > splitAt₁ > [mark, cons₁, 0]
afterNth > [active₁, natsFrom₁] > snd₁ > [mark, cons₁, 0]
afterNth > [active₁, natsFrom₁] > splitAt₁ > [mark, cons₁, 0]
afterNth > [active₁, natsFrom₁] > s₁ > [mark, cons₁, 0]
nil > [mark, cons₁, 0]
top > [mark, cons₁, 0]

Status:

ACTIVE₁: [1]
snd₁: [1]
active₁: [1]
tt: multiset
mark: []
splitAt₁: multiset
cons₁: [1]
afterNth: multiset
natsFrom₁: [1]
s₁: [1]
0: multiset
nil: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(139) Obligation:

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

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)
ACTIVE(tail(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(140) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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)
U12(x1, x2) = x1
fst(x1) = x1
head(x1) = x1
tail(x1) = tail(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = x2
tt = tt
mark(x1) = mark
splitAt(x1, x2) = splitAt(x1)
pair(x1, x2) = pair(x1, x2)
cons(x1, x2) = cons
afterNth(x1, x2) = x1
snd(x1) = x1
and(x1, x2) = x1
natsFrom(x1) = natsFrom
s(x1) = x1
sel(x1, x2) = sel
0 = 0
nil = nil
take(x1, x2) = x1
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

ACTIVE₁ > [tt, mark]
cons > [tail₁, active₁, proper₁] > splitAt₁ > [tt, mark]
cons > [tail₁, active₁, proper₁] > pair₂ > [tt, mark]
cons > [tail₁, active₁, proper₁] > sel > [tt, mark]
cons > [tail₁, active₁, proper₁] > 0 > [tt, mark]
cons > [tail₁, active₁, proper₁] > nil > [tt, mark]
natsFrom > [tail₁, active₁, proper₁] > splitAt₁ > [tt, mark]
natsFrom > [tail₁, active₁, proper₁] > pair₂ > [tt, mark]
natsFrom > [tail₁, active₁, proper₁] > sel > [tt, mark]
natsFrom > [tail₁, active₁, proper₁] > 0 > [tt, mark]
natsFrom > [tail₁, active₁, proper₁] > nil > [tt, mark]
top > [tt, mark]

Status:

ACTIVE₁: [1]
tail₁: [1]
active₁: [1]
tt: multiset
mark: multiset
splitAt₁: multiset
pair₂: multiset
cons: []
natsFrom: []
sel: multiset
0: multiset
nil: multiset
proper₁: [1]
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(141) Obligation:

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

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → ACTIVE(X)
ACTIVE(head(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

(142) 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)
U12(x1, x2) = x1
fst(x1) = x1
head(x1) = head(x1)
active(x1) = active(x1)
U11(x1, x2, x3, x4) = U11(x2)
tt = tt
mark(x1) = mark
splitAt(x1, x2) = splitAt(x1, x2)
pair(x1, x2) = x2
cons(x1, x2) = x1
afterNth(x1, x2) = x2
snd(x1) = snd
and(x1, x2) = x1
natsFrom(x1) = natsFrom
s(x1) = s
sel(x1, x2) = x1
0 = 0
nil = nil
tail(x1) = tail
take(x1, x2) = take
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

[s, proper₁] > U11₁ > active₁ > splitAt₂ > [ACTIVE₁, head₁, mark, natsFrom, take]
[s, proper₁] > tt > splitAt₂ > [ACTIVE₁, head₁, mark, natsFrom, take]
[s, proper₁] > snd > active₁ > splitAt₂ > [ACTIVE₁, head₁, mark, natsFrom, take]
[s, proper₁] > 0 > [ACTIVE₁, head₁, mark, natsFrom, take]
[s, proper₁] > nil > [ACTIVE₁, head₁, mark, natsFrom, take]
[s, proper₁] > tail > active₁ > splitAt₂ > [ACTIVE₁, head₁, mark, natsFrom, take]
top > active₁ > splitAt₂ > [ACTIVE₁, head₁, mark, natsFrom, take]

Status:

ACTIVE₁: multiset
head₁: multiset
active₁: [1]
U11₁: [1]
tt: multiset
mark: []
splitAt₂: [1,2]
snd: []
natsFrom: []
s: multiset
0: multiset
nil: multiset
tail: []
take: []
proper₁: [1]
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(143) Obligation:

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

ACTIVE(U12(X1, X2)) → ACTIVE(X1)
ACTIVE(fst(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

ACTIVE(U12(X1, X2)) → ACTIVE(X1)

The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1) = ACTIVE(x1)
U12(x1, x2) = U12(x1)
fst(x1) = x1
active(x1) = x1
U11(x1, x2, x3, x4) = x1
tt = tt
mark(x1) = mark
splitAt(x1, x2) = splitAt(x1)
pair(x1, x2) = x2
cons(x1, x2) = cons(x1, x2)
afterNth(x1, x2) = afterNth
snd(x1) = x1
and(x1, x2) = and(x1, x2)
head(x1) = x1
natsFrom(x1) = natsFrom(x1)
s(x1) = s
sel(x1, x2) = x1
0 = 0
nil = nil
tail(x1) = tail(x1)
take(x1, x2) = take
proper(x1) = proper(x1)
ok(x1) = ok
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

ACTIVE₁ > [U12₁, tt, mark, cons₂, top]
afterNth > [tail₁, proper₁] > splitAt₁ > nil > [take, ok] > [U12₁, tt, mark, cons₂, top]
afterNth > [tail₁, proper₁] > and₂ > [take, ok] > [U12₁, tt, mark, cons₂, top]
afterNth > [tail₁, proper₁] > natsFrom₁ > [take, ok] > [U12₁, tt, mark, cons₂, top]
afterNth > [tail₁, proper₁] > s > [take, ok] > [U12₁, tt, mark, cons₂, top]
afterNth > [tail₁, proper₁] > 0 > nil > [take, ok] > [U12₁, tt, mark, cons₂, top]

Status:

ACTIVE₁: [1]
U12₁: [1]
tt: multiset
mark: []
splitAt₁: multiset
cons₂: [1,2]
afterNth: multiset
and₂: [2,1]
natsFrom₁: [1]
s: []
0: multiset
nil: multiset
tail₁: [1]
take: []
proper₁: [1]
ok: []
top: multiset

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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:

ACTIVE(fst(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.

ACTIVE(fst(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)
active(x1) = x1
U11(x1, x2, x3, x4) = x3
tt = tt
mark(x1) = mark
U12(x1, x2) = U12(x2)
splitAt(x1, x2) = x1
pair(x1, x2) = pair
cons(x1, x2) = x2
afterNth(x1, x2) = x1
snd(x1) = snd
and(x1, x2) = x2
head(x1) = x1
natsFrom(x1) = x1
s(x1) = s
sel(x1, x2) = x2
0 = 0
nil = nil
tail(x1) = tail
take(x1, x2) = take
proper(x1) = proper(x1)
ok(x1) = x1
top(x1) = top

Recursive path order with status [RPO].
Quasi-Precedence:

pair > [fst₁, U12₁, proper₁] > ACTIVE₁ > mark
pair > [fst₁, U12₁, proper₁] > tt > mark
snd > [fst₁, U12₁, proper₁] > ACTIVE₁ > mark
snd > [fst₁, U12₁, proper₁] > tt > mark
s > [fst₁, U12₁, proper₁] > ACTIVE₁ > mark
s > [fst₁, U12₁, proper₁] > tt > mark
0 > mark
nil > mark
tail > [fst₁, U12₁, proper₁] > ACTIVE₁ > mark
tail > [fst₁, U12₁, proper₁] > tt > mark
take > [fst₁, U12₁, proper₁] > ACTIVE₁ > mark
take > [fst₁, U12₁, proper₁] > tt > mark
top > [fst₁, U12₁, proper₁] > ACTIVE₁ > mark
top > [fst₁, U12₁, proper₁] > tt > mark

Status:

ACTIVE₁: multiset
fst₁: multiset
tt: multiset
mark: []
U12₁: multiset
pair: []
snd: multiset
s: multiset
0: multiset
nil: multiset
tail: multiset
take: multiset
proper₁: multiset
top: []

The following usable rules [FROCOS05] were oriented:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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:

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

The TRS R consists of the following rules:

active(U11(tt, N, X, XS)) → mark(U12(splitAt(N, XS), X))
active(U12(pair(YS, ZS), X)) → mark(pair(cons(X, YS), ZS))
active(afterNth(N, XS)) → mark(snd(splitAt(N, XS)))
active(and(tt, X)) → mark(X)
active(fst(pair(X, Y))) → mark(X)
active(head(cons(N, XS))) → mark(N)
active(natsFrom(N)) → mark(cons(N, natsFrom(s(N))))
active(sel(N, XS)) → mark(head(afterNth(N, XS)))
active(snd(pair(X, Y))) → mark(Y)
active(splitAt(0, XS)) → mark(pair(nil, XS))
active(splitAt(s(N), cons(X, XS))) → mark(U11(tt, N, X, XS))
active(tail(cons(N, XS))) → mark(XS)
active(take(N, XS)) → mark(fst(splitAt(N, XS)))
active(U11(X1, X2, X3, X4)) → U11(active(X1), X2, X3, X4)
active(U12(X1, X2)) → U12(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(active(X1), X2)
active(splitAt(X1, X2)) → splitAt(X1, active(X2))
active(pair(X1, X2)) → pair(active(X1), X2)
active(pair(X1, X2)) → pair(X1, active(X2))
active(cons(X1, X2)) → cons(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(active(X1), X2)
active(afterNth(X1, X2)) → afterNth(X1, active(X2))
active(snd(X)) → snd(active(X))
active(and(X1, X2)) → and(active(X1), X2)
active(fst(X)) → fst(active(X))
active(head(X)) → head(active(X))
active(natsFrom(X)) → natsFrom(active(X))
active(s(X)) → s(active(X))
active(sel(X1, X2)) → sel(active(X1), X2)
active(sel(X1, X2)) → sel(X1, active(X2))
active(tail(X)) → tail(active(X))
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
U11(mark(X1), X2, X3, X4) → mark(U11(X1, X2, X3, X4))
U12(mark(X1), X2) → mark(U12(X1, X2))
splitAt(mark(X1), X2) → mark(splitAt(X1, X2))
splitAt(X1, mark(X2)) → mark(splitAt(X1, X2))
pair(mark(X1), X2) → mark(pair(X1, X2))
pair(X1, mark(X2)) → mark(pair(X1, X2))
cons(mark(X1), X2) → mark(cons(X1, X2))
afterNth(mark(X1), X2) → mark(afterNth(X1, X2))
afterNth(X1, mark(X2)) → mark(afterNth(X1, X2))
snd(mark(X)) → mark(snd(X))
and(mark(X1), X2) → mark(and(X1, X2))
fst(mark(X)) → mark(fst(X))
head(mark(X)) → mark(head(X))
natsFrom(mark(X)) → mark(natsFrom(X))
s(mark(X)) → mark(s(X))
sel(mark(X1), X2) → mark(sel(X1, X2))
sel(X1, mark(X2)) → mark(sel(X1, X2))
tail(mark(X)) → mark(tail(X))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
proper(U11(X1, X2, X3, X4)) → U11(proper(X1), proper(X2), proper(X3), proper(X4))
proper(tt) → ok(tt)
proper(U12(X1, X2)) → U12(proper(X1), proper(X2))
proper(splitAt(X1, X2)) → splitAt(proper(X1), proper(X2))
proper(pair(X1, X2)) → pair(proper(X1), proper(X2))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(afterNth(X1, X2)) → afterNth(proper(X1), proper(X2))
proper(snd(X)) → snd(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(fst(X)) → fst(proper(X))
proper(head(X)) → head(proper(X))
proper(natsFrom(X)) → natsFrom(proper(X))
proper(s(X)) → s(proper(X))
proper(sel(X1, X2)) → sel(proper(X1), proper(X2))
proper(0) → ok(0)
proper(nil) → ok(nil)
proper(tail(X)) → tail(proper(X))
proper(take(X1, X2)) → take(proper(X1), proper(X2))
U11(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(U11(X1, X2, X3, X4))
U12(ok(X1), ok(X2)) → ok(U12(X1, X2))
splitAt(ok(X1), ok(X2)) → ok(splitAt(X1, X2))
pair(ok(X1), ok(X2)) → ok(pair(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
afterNth(ok(X1), ok(X2)) → ok(afterNth(X1, X2))
snd(ok(X)) → ok(snd(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
fst(ok(X)) → ok(fst(X))
head(ok(X)) → ok(head(X))
natsFrom(ok(X)) → ok(natsFrom(X))
s(ok(X)) → ok(s(X))
sel(ok(X1), ok(X2)) → ok(sel(X1, X2))
tail(ok(X)) → ok(tail(X))
take(ok(X1), ok(X2)) → ok(take(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.