YES Termination proof of ../tpdb/TRS/CSR_Maude/PEPM04/LISTUTILITIES_nosorts.trs
Termination of the following Term Rewriting System could be proven:

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

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
splitAt: {1, 2}
pair: {1, 2}
cons: {1}
afterNth: {1, 2}
snd: {1}
and: {1}
fst: {1}
head: {1}
natsFrom: {1}
s: {1}
sel: {1, 2}
0: empty set
nil: empty set
tail: {1}
take: {1, 2}


↳ CSR
  ↳ Zantema-Transformation

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

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
splitAt: {1, 2}
pair: {1, 2}
cons: {1}
afterNth: {1, 2}
snd: {1}
and: {1}
fst: {1}
head: {1}
natsFrom: {1}
s: {1}
sel: {1, 2}
0: empty set
nil: empty set
tail: {1}
take: {1, 2}

We applied the Zantema [34] to transform the context-sensitive TRS to an usual TRS.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof

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

U11(tt, N, X, XS) → U12(splitAt(a(N), a(XS)), a(X))
U12(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → a(X)
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, a(XS))
tail(cons(N, XS)) → a(XS)
take(N, XS) → fst(splitAt(N, XS))
a(x) → x
natsFrom(x1) → natsFromInact(x1)
a(natsFromInact(x1)) → natsFrom(x1)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

TAKE(N, XS) → SPLITAT(N, XS)
AFTERNTH(N, XS) → SPLITAT(N, XS)
SEL(N, XS) → HEAD(afterNth(N, XS))
SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, a(XS))
U111(tt, N, X, XS) → A(N)
SPLITAT(s(N), cons(X, XS)) → A(XS)
SEL(N, XS) → AFTERNTH(N, XS)
U121(pair(YS, ZS), X) → A(X)
AFTERNTH(N, XS) → SND(splitAt(N, XS))
U111(tt, N, X, XS) → A(XS)
A(natsFromInact(x1)) → NATSFROM(x1)
U111(tt, N, X, XS) → SPLITAT(a(N), a(XS))
TAIL(cons(N, XS)) → A(XS)
U111(tt, N, X, XS) → U121(splitAt(a(N), a(XS)), a(X))
TAKE(N, XS) → FST(splitAt(N, XS))
U111(tt, N, X, XS) → A(X)
AND(tt, X) → A(X)

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(a(N), a(XS)), a(X))
U12(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → a(X)
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, a(XS))
tail(cons(N, XS)) → a(XS)
take(N, XS) → fst(splitAt(N, XS))
a(x) → x
natsFrom(x1) → natsFromInact(x1)
a(natsFromInact(x1)) → natsFrom(x1)

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof

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

TAKE(N, XS) → SPLITAT(N, XS)
AFTERNTH(N, XS) → SPLITAT(N, XS)
SEL(N, XS) → HEAD(afterNth(N, XS))
SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, a(XS))
U111(tt, N, X, XS) → A(N)
SPLITAT(s(N), cons(X, XS)) → A(XS)
SEL(N, XS) → AFTERNTH(N, XS)
U121(pair(YS, ZS), X) → A(X)
AFTERNTH(N, XS) → SND(splitAt(N, XS))
U111(tt, N, X, XS) → A(XS)
A(natsFromInact(x1)) → NATSFROM(x1)
U111(tt, N, X, XS) → SPLITAT(a(N), a(XS))
TAIL(cons(N, XS)) → A(XS)
U111(tt, N, X, XS) → U121(splitAt(a(N), a(XS)), a(X))
TAKE(N, XS) → FST(splitAt(N, XS))
U111(tt, N, X, XS) → A(X)
AND(tt, X) → A(X)

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(a(N), a(XS)), a(X))
U12(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → a(X)
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, a(XS))
tail(cons(N, XS)) → a(XS)
take(N, XS) → fst(splitAt(N, XS))
a(x) → x
natsFrom(x1) → natsFromInact(x1)
a(natsFromInact(x1)) → natsFrom(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 15 less nodes.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof

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

SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, a(XS))
U111(tt, N, X, XS) → SPLITAT(a(N), a(XS))

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(a(N), a(XS)), a(X))
U12(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → a(X)
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, a(XS))
tail(cons(N, XS)) → a(XS)
take(N, XS) → fst(splitAt(N, XS))
a(x) → x
natsFrom(x1) → natsFromInact(x1)
a(natsFromInact(x1)) → natsFrom(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, a(XS))
U111(tt, N, X, XS) → SPLITAT(a(N), a(XS))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
SPLITAT(x1, x2)  =  x1
s(x1)  =  s(x1)
cons(x1, x2)  =  x2
U111(x1, x2, x3, x4)  =  U111(x1, x2)
tt  =  tt
a(x1)  =  x1
natsFrom(x1)  =  natsFrom
natsFromInact(x1)  =  natsFromInact

Recursive path order with status [2].
Quasi-Precedence:
[natsFrom, natsFromInact] > s1 > tt > U11^12

Status:
s1: [1]
natsFrom: multiset
U11^12: [1,2]
natsFromInact: multiset
tt: multiset


The following usable rules [17] were oriented:

a(x) → x
natsFrom(x1) → natsFromInact(x1)
natsFrom(N) → cons(N, natsFromInact(s(N)))
a(natsFromInact(x1)) → natsFrom(x1)



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ PisEmptyProof

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

U11(tt, N, X, XS) → U12(splitAt(a(N), a(XS)), a(X))
U12(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → a(X)
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, a(XS))
tail(cons(N, XS)) → a(XS)
take(N, XS) → fst(splitAt(N, XS))
a(x) → x
natsFrom(x1) → natsFromInact(x1)
a(natsFromInact(x1)) → natsFrom(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.