YES Termination proof of ../tpdb/TRS/CSR_Maude/PEPM04/LISTUTILITIES_nosorts-noand.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, XS) → U12(tt, N, XS)
U12(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → U22(tt, X)
U22(tt, X) → X
U31(tt, N) → U32(tt, N)
U32(tt, N) → N
U41(tt, N, XS) → U42(tt, N, XS)
U42(tt, N, XS) → head(afterNth(N, XS))
U51(tt, Y) → U52(tt, Y)
U52(tt, Y) → Y
U61(tt, N, X, XS) → U62(tt, N, X, XS)
U62(tt, N, X, XS) → U63(tt, N, X, XS)
U63(tt, N, X, XS) → U64(splitAt(N, XS), X)
U64(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U71(tt, XS) → U72(tt, XS)
U72(tt, XS) → XS
U81(tt, N, XS) → U82(tt, N, XS)
U82(tt, N, XS) → fst(splitAt(N, XS))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, XS)
tail(cons(N, XS)) → U71(tt, XS)
take(N, XS) → U81(tt, N, XS)

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
snd: {1}
splitAt: {1, 2}
U21: {1}
U22: {1}
U31: {1}
U32: {1}
U41: {1}
U42: {1}
head: {1}
afterNth: {1, 2}
U51: {1}
U52: {1}
U61: {1}
U62: {1}
U63: {1}
U64: {1}
pair: {1, 2}
cons: {1}
U71: {1}
U72: {1}
U81: {1}
U82: {1}
fst: {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, XS) → U12(tt, N, XS)
U12(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → U22(tt, X)
U22(tt, X) → X
U31(tt, N) → U32(tt, N)
U32(tt, N) → N
U41(tt, N, XS) → U42(tt, N, XS)
U42(tt, N, XS) → head(afterNth(N, XS))
U51(tt, Y) → U52(tt, Y)
U52(tt, Y) → Y
U61(tt, N, X, XS) → U62(tt, N, X, XS)
U62(tt, N, X, XS) → U63(tt, N, X, XS)
U63(tt, N, X, XS) → U64(splitAt(N, XS), X)
U64(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U71(tt, XS) → U72(tt, XS)
U72(tt, XS) → XS
U81(tt, N, XS) → U82(tt, N, XS)
U82(tt, N, XS) → fst(splitAt(N, XS))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, XS)
tail(cons(N, XS)) → U71(tt, XS)
take(N, XS) → U81(tt, N, XS)

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
snd: {1}
splitAt: {1, 2}
U21: {1}
U22: {1}
U31: {1}
U32: {1}
U41: {1}
U42: {1}
head: {1}
afterNth: {1, 2}
U51: {1}
U52: {1}
U61: {1}
U62: {1}
U63: {1}
U64: {1}
pair: {1, 2}
cons: {1}
U71: {1}
U72: {1}
U81: {1}
U82: {1}
fst: {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, XS) → U12(tt, a(N), a(XS))
U12(tt, N, XS) → snd(splitAt(a(N), a(XS)))
U21(tt, X) → U22(tt, a(X))
U22(tt, X) → a(X)
U31(tt, N) → U32(tt, a(N))
U32(tt, N) → a(N)
U41(tt, N, XS) → U42(tt, a(N), a(XS))
U42(tt, N, XS) → head(afterNth(a(N), a(XS)))
U51(tt, Y) → U52(tt, a(Y))
U52(tt, Y) → a(Y)
U61(tt, N, X, XS) → U62(tt, a(N), a(X), a(XS))
U62(tt, N, X, XS) → U63(tt, a(N), a(X), a(XS))
U63(tt, N, X, XS) → U64(splitAt(a(N), a(XS)), a(X))
U64(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
U71(tt, XS) → U72(tt, a(XS))
U72(tt, XS) → a(XS)
U81(tt, N, XS) → U82(tt, a(N), a(XS))
U82(tt, N, XS) → fst(splitAt(a(N), a(XS)))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, a(XS))
tail(cons(N, XS)) → U71(tt, a(XS))
take(N, XS) → U81(tt, 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:

U631(tt, N, X, XS) → SPLITAT(a(N), a(XS))
U811(tt, N, XS) → A(XS)
U641(pair(YS, ZS), X) → A(X)
U821(tt, N, XS) → A(N)
FST(pair(X, Y)) → U211(tt, X)
U611(tt, N, X, XS) → A(N)
SPLITAT(s(N), cons(X, XS)) → U611(tt, N, X, a(XS))
TAIL(cons(N, XS)) → A(XS)
SND(pair(X, Y)) → U511(tt, Y)
U311(tt, N) → A(N)
U111(tt, N, XS) → A(N)
U211(tt, X) → A(X)
U421(tt, N, XS) → AFTERNTH(a(N), a(XS))
HEAD(cons(N, XS)) → U311(tt, N)
U211(tt, X) → U221(tt, a(X))
U411(tt, N, XS) → A(N)
TAKE(N, XS) → U811(tt, N, XS)
U631(tt, N, X, XS) → A(X)
U311(tt, N) → U321(tt, a(N))
U821(tt, N, XS) → FST(splitAt(a(N), a(XS)))
A(natsFromInact(x1)) → NATSFROM(x1)
U521(tt, Y) → A(Y)
U811(tt, N, XS) → U821(tt, a(N), a(XS))
U711(tt, XS) → U721(tt, a(XS))
U421(tt, N, XS) → A(XS)
U411(tt, N, XS) → U421(tt, a(N), a(XS))
U611(tt, N, X, XS) → A(X)
U111(tt, N, XS) → U121(tt, a(N), a(XS))
U121(tt, N, XS) → A(N)
U511(tt, Y) → A(Y)
SPLITAT(s(N), cons(X, XS)) → A(XS)
U811(tt, N, XS) → A(N)
U621(tt, N, X, XS) → U631(tt, a(N), a(X), a(XS))
U421(tt, N, XS) → A(N)
SEL(N, XS) → U411(tt, N, XS)
AFTERNTH(N, XS) → U111(tt, N, XS)
U221(tt, X) → A(X)
U621(tt, N, X, XS) → A(N)
U631(tt, N, X, XS) → U641(splitAt(a(N), a(XS)), a(X))
TAIL(cons(N, XS)) → U711(tt, a(XS))
U621(tt, N, X, XS) → A(XS)
U631(tt, N, X, XS) → A(XS)
U621(tt, N, X, XS) → A(X)
U821(tt, N, XS) → SPLITAT(a(N), a(XS))
U821(tt, N, XS) → A(XS)
U511(tt, Y) → U521(tt, a(Y))
U611(tt, N, X, XS) → A(XS)
U421(tt, N, XS) → HEAD(afterNth(a(N), a(XS)))
U711(tt, XS) → A(XS)
U121(tt, N, XS) → SND(splitAt(a(N), a(XS)))
U721(tt, XS) → A(XS)
U611(tt, N, X, XS) → U621(tt, a(N), a(X), a(XS))
U111(tt, N, XS) → A(XS)
U321(tt, N) → A(N)
U121(tt, N, XS) → SPLITAT(a(N), a(XS))
U631(tt, N, X, XS) → A(N)
U411(tt, N, XS) → A(XS)
U121(tt, N, XS) → A(XS)

The TRS R consists of the following rules:

U11(tt, N, XS) → U12(tt, a(N), a(XS))
U12(tt, N, XS) → snd(splitAt(a(N), a(XS)))
U21(tt, X) → U22(tt, a(X))
U22(tt, X) → a(X)
U31(tt, N) → U32(tt, a(N))
U32(tt, N) → a(N)
U41(tt, N, XS) → U42(tt, a(N), a(XS))
U42(tt, N, XS) → head(afterNth(a(N), a(XS)))
U51(tt, Y) → U52(tt, a(Y))
U52(tt, Y) → a(Y)
U61(tt, N, X, XS) → U62(tt, a(N), a(X), a(XS))
U62(tt, N, X, XS) → U63(tt, a(N), a(X), a(XS))
U63(tt, N, X, XS) → U64(splitAt(a(N), a(XS)), a(X))
U64(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
U71(tt, XS) → U72(tt, a(XS))
U72(tt, XS) → a(XS)
U81(tt, N, XS) → U82(tt, a(N), a(XS))
U82(tt, N, XS) → fst(splitAt(a(N), a(XS)))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, a(XS))
tail(cons(N, XS)) → U71(tt, a(XS))
take(N, XS) → U81(tt, 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:

U631(tt, N, X, XS) → SPLITAT(a(N), a(XS))
U811(tt, N, XS) → A(XS)
U641(pair(YS, ZS), X) → A(X)
U821(tt, N, XS) → A(N)
FST(pair(X, Y)) → U211(tt, X)
U611(tt, N, X, XS) → A(N)
SPLITAT(s(N), cons(X, XS)) → U611(tt, N, X, a(XS))
TAIL(cons(N, XS)) → A(XS)
SND(pair(X, Y)) → U511(tt, Y)
U311(tt, N) → A(N)
U111(tt, N, XS) → A(N)
U211(tt, X) → A(X)
U421(tt, N, XS) → AFTERNTH(a(N), a(XS))
HEAD(cons(N, XS)) → U311(tt, N)
U211(tt, X) → U221(tt, a(X))
U411(tt, N, XS) → A(N)
TAKE(N, XS) → U811(tt, N, XS)
U631(tt, N, X, XS) → A(X)
U311(tt, N) → U321(tt, a(N))
U821(tt, N, XS) → FST(splitAt(a(N), a(XS)))
A(natsFromInact(x1)) → NATSFROM(x1)
U521(tt, Y) → A(Y)
U811(tt, N, XS) → U821(tt, a(N), a(XS))
U711(tt, XS) → U721(tt, a(XS))
U421(tt, N, XS) → A(XS)
U411(tt, N, XS) → U421(tt, a(N), a(XS))
U611(tt, N, X, XS) → A(X)
U111(tt, N, XS) → U121(tt, a(N), a(XS))
U121(tt, N, XS) → A(N)
U511(tt, Y) → A(Y)
SPLITAT(s(N), cons(X, XS)) → A(XS)
U811(tt, N, XS) → A(N)
U621(tt, N, X, XS) → U631(tt, a(N), a(X), a(XS))
U421(tt, N, XS) → A(N)
SEL(N, XS) → U411(tt, N, XS)
AFTERNTH(N, XS) → U111(tt, N, XS)
U221(tt, X) → A(X)
U621(tt, N, X, XS) → A(N)
U631(tt, N, X, XS) → U641(splitAt(a(N), a(XS)), a(X))
TAIL(cons(N, XS)) → U711(tt, a(XS))
U621(tt, N, X, XS) → A(XS)
U631(tt, N, X, XS) → A(XS)
U621(tt, N, X, XS) → A(X)
U821(tt, N, XS) → SPLITAT(a(N), a(XS))
U821(tt, N, XS) → A(XS)
U511(tt, Y) → U521(tt, a(Y))
U611(tt, N, X, XS) → A(XS)
U421(tt, N, XS) → HEAD(afterNth(a(N), a(XS)))
U711(tt, XS) → A(XS)
U121(tt, N, XS) → SND(splitAt(a(N), a(XS)))
U721(tt, XS) → A(XS)
U611(tt, N, X, XS) → U621(tt, a(N), a(X), a(XS))
U111(tt, N, XS) → A(XS)
U321(tt, N) → A(N)
U121(tt, N, XS) → SPLITAT(a(N), a(XS))
U631(tt, N, X, XS) → A(N)
U411(tt, N, XS) → A(XS)
U121(tt, N, XS) → A(XS)

The TRS R consists of the following rules:

U11(tt, N, XS) → U12(tt, a(N), a(XS))
U12(tt, N, XS) → snd(splitAt(a(N), a(XS)))
U21(tt, X) → U22(tt, a(X))
U22(tt, X) → a(X)
U31(tt, N) → U32(tt, a(N))
U32(tt, N) → a(N)
U41(tt, N, XS) → U42(tt, a(N), a(XS))
U42(tt, N, XS) → head(afterNth(a(N), a(XS)))
U51(tt, Y) → U52(tt, a(Y))
U52(tt, Y) → a(Y)
U61(tt, N, X, XS) → U62(tt, a(N), a(X), a(XS))
U62(tt, N, X, XS) → U63(tt, a(N), a(X), a(XS))
U63(tt, N, X, XS) → U64(splitAt(a(N), a(XS)), a(X))
U64(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
U71(tt, XS) → U72(tt, a(XS))
U72(tt, XS) → a(XS)
U81(tt, N, XS) → U82(tt, a(N), a(XS))
U82(tt, N, XS) → fst(splitAt(a(N), a(XS)))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, a(XS))
tail(cons(N, XS)) → U71(tt, a(XS))
take(N, XS) → U81(tt, 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 54 less nodes.

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

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

U631(tt, N, X, XS) → SPLITAT(a(N), a(XS))
U621(tt, N, X, XS) → U631(tt, a(N), a(X), a(XS))
U611(tt, N, X, XS) → U621(tt, a(N), a(X), a(XS))
SPLITAT(s(N), cons(X, XS)) → U611(tt, N, X, a(XS))

The TRS R consists of the following rules:

U11(tt, N, XS) → U12(tt, a(N), a(XS))
U12(tt, N, XS) → snd(splitAt(a(N), a(XS)))
U21(tt, X) → U22(tt, a(X))
U22(tt, X) → a(X)
U31(tt, N) → U32(tt, a(N))
U32(tt, N) → a(N)
U41(tt, N, XS) → U42(tt, a(N), a(XS))
U42(tt, N, XS) → head(afterNth(a(N), a(XS)))
U51(tt, Y) → U52(tt, a(Y))
U52(tt, Y) → a(Y)
U61(tt, N, X, XS) → U62(tt, a(N), a(X), a(XS))
U62(tt, N, X, XS) → U63(tt, a(N), a(X), a(XS))
U63(tt, N, X, XS) → U64(splitAt(a(N), a(XS)), a(X))
U64(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
U71(tt, XS) → U72(tt, a(XS))
U72(tt, XS) → a(XS)
U81(tt, N, XS) → U82(tt, a(N), a(XS))
U82(tt, N, XS) → fst(splitAt(a(N), a(XS)))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, a(XS))
tail(cons(N, XS)) → U71(tt, a(XS))
take(N, XS) → U81(tt, 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)) → U611(tt, N, X, a(XS))
The remaining pairs can at least be oriented weakly.

U631(tt, N, X, XS) → SPLITAT(a(N), a(XS))
U621(tt, N, X, XS) → U631(tt, a(N), a(X), a(XS))
U611(tt, N, X, XS) → U621(tt, a(N), a(X), a(XS))
Used ordering: Polynomial interpretation [25]:

POL(SPLITAT(x1, x2)) = x1   
POL(U611(x1, x2, x3, x4)) = x2   
POL(U621(x1, x2, x3, x4)) = x2   
POL(U631(x1, x2, x3, x4)) = x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 0   
POL(natsFrom(x1)) = 0   
POL(natsFromInact(x1)) = 0   
POL(s(x1)) = 1 + x1   
POL(tt) = 0   

The following usable rules [17] were oriented:

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



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

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

U631(tt, N, X, XS) → SPLITAT(a(N), a(XS))
U621(tt, N, X, XS) → U631(tt, a(N), a(X), a(XS))
U611(tt, N, X, XS) → U621(tt, a(N), a(X), a(XS))

The TRS R consists of the following rules:

U11(tt, N, XS) → U12(tt, a(N), a(XS))
U12(tt, N, XS) → snd(splitAt(a(N), a(XS)))
U21(tt, X) → U22(tt, a(X))
U22(tt, X) → a(X)
U31(tt, N) → U32(tt, a(N))
U32(tt, N) → a(N)
U41(tt, N, XS) → U42(tt, a(N), a(XS))
U42(tt, N, XS) → head(afterNth(a(N), a(XS)))
U51(tt, Y) → U52(tt, a(Y))
U52(tt, Y) → a(Y)
U61(tt, N, X, XS) → U62(tt, a(N), a(X), a(XS))
U62(tt, N, X, XS) → U63(tt, a(N), a(X), a(XS))
U63(tt, N, X, XS) → U64(splitAt(a(N), a(XS)), a(X))
U64(pair(YS, ZS), X) → pair(cons(a(X), YS), ZS)
U71(tt, XS) → U72(tt, a(XS))
U72(tt, XS) → a(XS)
U81(tt, N, XS) → U82(tt, a(N), a(XS))
U82(tt, N, XS) → fst(splitAt(a(N), a(XS)))
afterNth(N, XS) → U11(tt, N, XS)
fst(pair(X, Y)) → U21(tt, X)
head(cons(N, XS)) → U31(tt, N)
natsFrom(N) → cons(N, natsFromInact(s(N)))
sel(N, XS) → U41(tt, N, XS)
snd(pair(X, Y)) → U51(tt, Y)
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U61(tt, N, X, a(XS))
tail(cons(N, XS)) → U71(tt, a(XS))
take(N, XS) → U81(tt, 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 0 SCCs with 3 less nodes.