Termination of the following Term Rewriting System could be proven:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

nats → cons(0, incr(nats))
pairs → cons(0, incr(odds))
odds → incr(pairs)
incr(cons(X, XS)) → cons(s(X), incr(XS))
head(cons(X, XS)) → X
tail(cons(X, XS)) → XS

The replacement map contains the following entries:

nats: empty set
cons: {1}
0: empty set
incr: {1}
pairs: empty set
odds: empty set
s: {1}
head: {1}
tail: {1}


↳ CSR
  ↳ CSRInnermostProof

Context-sensitive rewrite system:
The TRS R consists of the following rules:

nats → cons(0, incr(nats))
pairs → cons(0, incr(odds))
odds → incr(pairs)
incr(cons(X, XS)) → cons(s(X), incr(XS))
head(cons(X, XS)) → X
tail(cons(X, XS)) → XS

The replacement map contains the following entries:

nats: empty set
cons: {1}
0: empty set
incr: {1}
pairs: empty set
odds: empty set
s: {1}
head: {1}
tail: {1}

The CSR is orthogonal. By [10] we can switch to innermost.

↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof

Context-sensitive rewrite system:
The TRS R consists of the following rules:

nats → cons(0, incr(nats))
pairs → cons(0, incr(odds))
odds → incr(pairs)
incr(cons(X, XS)) → cons(s(X), incr(XS))
head(cons(X, XS)) → X
tail(cons(X, XS)) → XS

The replacement map contains the following entries:

nats: empty set
cons: {1}
0: empty set
incr: {1}
pairs: empty set
odds: empty set
s: {1}
head: {1}
tail: {1}

Innermost Strategy.

Using Improved CS-DPs we result in the following initial Q-CSDP problem.

↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof

Q-restricted context-sensitive dependency pair problem:
The symbols in {incr, s, head, tail, INCR, TAIL} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {U} are not replacing on any position.

The ordinary context-sensitive dependency pairs DPo are:

ODDS → INCR(pairs)
ODDS → PAIRS

The collapsing dependency pairs are DPc:

TAIL(cons(X, XS)) → XS


The hidden terms of R are:

incr(nats)
nats
incr(odds)
odds
incr(XS)

Every hiding context is built from:

incr on positions {1}

Hence, the new unhiding pairs DPu are :

TAIL(cons(X, XS)) → U(XS)
U(incr(x_0)) → U(x_0)
U(incr(nats)) → INCR(nats)
U(nats) → NATS
U(incr(odds)) → INCR(odds)
U(odds) → ODDS
U(incr(XS)) → INCR(XS)

The TRS R consists of the following rules:

nats → cons(0, incr(nats))
pairs → cons(0, incr(odds))
odds → incr(pairs)
incr(cons(X, XS)) → cons(s(X), incr(XS))
head(cons(X, XS)) → X
tail(cons(X, XS)) → XS

The set Q consists of the following terms:

nats
pairs
odds
incr(cons(x0, x1))
head(cons(x0, x1))
tail(cons(x0, x1))


The approximation of the Context-Sensitive Dependency Graph contains 1 SCC with 8 less nodes.


↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof
            ↳ QCSDP
              ↳ QCSDPSubtermProof

Q-restricted context-sensitive dependency pair problem:
The symbols in {incr, s, head, tail} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.
The symbols in {U} are not replacing on any position.

The TRS P consists of the following rules:

U(incr(x_0)) → U(x_0)

The TRS R consists of the following rules:

nats → cons(0, incr(nats))
pairs → cons(0, incr(odds))
odds → incr(pairs)
incr(cons(X, XS)) → cons(s(X), incr(XS))
head(cons(X, XS)) → X
tail(cons(X, XS)) → XS

The set Q consists of the following terms:

nats
pairs
odds
incr(cons(x0, x1))
head(cons(x0, x1))
tail(cons(x0, x1))


We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


U(incr(x_0)) → U(x_0)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
U(x1)  =  x1

Subterm Order


↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof
            ↳ QCSDP
              ↳ QCSDPSubtermProof
                ↳ QCSDP
                  ↳ PIsEmptyProof

Q-restricted context-sensitive dependency pair problem:
The symbols in {incr, s, head, tail} are replacing on all positions.
For all symbols f in {cons} we have µ(f) = {1}.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

nats → cons(0, incr(nats))
pairs → cons(0, incr(odds))
odds → incr(pairs)
incr(cons(X, XS)) → cons(s(X), incr(XS))
head(cons(X, XS)) → X
tail(cons(X, XS)) → XS

The set Q consists of the following terms:

nats
pairs
odds
incr(cons(x0, x1))
head(cons(x0, x1))
tail(cons(x0, x1))


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