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

0 QTRS
↳1 DependencyPairsProof (⇔)
↳2 QDP
↳3 DependencyGraphProof (⇔)
↳4 AND
  ↳5 QDP
    ↳6 UsableRulesProof (⇔)
    ↳7 QDP
    ↳8 QDPSizeChangeProof (⇔)
    ↳9 TRUE
  ↳10 QDP
    ↳11 UsableRulesProof (⇔)
    ↳12 QDP
    ↳13 QDPSizeChangeProof (⇔)
    ↳14 TRUE
  ↳15 QDP
    ↳16 UsableRulesProof (⇔)
    ↳17 QDP
    ↳18 QDPSizeChangeProof (⇔)
    ↳19 TRUE
  ↳20 QDP
    ↳21 UsableRulesProof (⇔)
    ↳22 QDP
    ↳23 QDPSizeChangeProof (⇔)
    ↳24 TRUE
  ↳25 QDP
    ↳26 UsableRulesProof (⇔)
    ↳27 QDP
    ↳28 QDPSizeChangeProof (⇔)
    ↳29 TRUE
  ↳30 QDP
    ↳31 QDPOrderProof (⇔)
    ↳32 QDP
    ↳33 QDPOrderProof (⇔)
    ↳34 QDP
    ↳35 QDPOrderProof (⇔)
    ↳36 QDP
    ↳37 UsableRulesProof (⇔)
    ↳38 QDP
    ↳39 UsableRulesReductionPairsProof (⇔)
    ↳40 QDP
    ↳41 DependencyGraphProof (⇔)
    ↳42 TRUE

(0) Obligation:

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

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(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(from(X)) → MARK(cons(X, from(s(X))))
ACTIVE(from(X)) → CONS(X, from(s(X)))
ACTIVE(from(X)) → FROM(s(X))
ACTIVE(from(X)) → S(X)
ACTIVE(length(nil)) → MARK(0)
ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
ACTIVE(length(cons(X, Y))) → S(length1(Y))
ACTIVE(length(cons(X, Y))) → LENGTH1(Y)
ACTIVE(length1(X)) → MARK(length(X))
ACTIVE(length1(X)) → LENGTH(X)
MARK(from(X)) → ACTIVE(from(mark(X)))
MARK(from(X)) → FROM(mark(X))
MARK(from(X)) → MARK(X)
MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
MARK(cons(X1, X2)) → CONS(mark(X1), X2)
MARK(cons(X1, X2)) → MARK(X1)
MARK(s(X)) → ACTIVE(s(mark(X)))
MARK(s(X)) → S(mark(X))
MARK(s(X)) → MARK(X)
MARK(length(X)) → ACTIVE(length(X))
MARK(nil) → ACTIVE(nil)
MARK(0) → ACTIVE(0)
MARK(length1(X)) → ACTIVE(length1(X))
FROM(mark(X)) → FROM(X)
FROM(active(X)) → FROM(X)
CONS(mark(X1), X2) → CONS(X1, X2)
CONS(X1, mark(X2)) → CONS(X1, X2)
CONS(active(X1), X2) → CONS(X1, X2)
CONS(X1, active(X2)) → CONS(X1, X2)
S(mark(X)) → S(X)
S(active(X)) → S(X)
LENGTH(mark(X)) → LENGTH(X)
LENGTH(active(X)) → LENGTH(X)
LENGTH1(mark(X)) → LENGTH1(X)
LENGTH1(active(X)) → LENGTH1(X)

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(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 6 SCCs with 12 less nodes.

(4) Complex Obligation (AND)

(5) Obligation:

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

LENGTH1(active(X)) → LENGTH1(X)
LENGTH1(mark(X)) → LENGTH1(X)

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(6) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(7) Obligation:

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

LENGTH1(active(X)) → LENGTH1(X)
LENGTH1(mark(X)) → LENGTH1(X)

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

(8) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • LENGTH1(active(X)) → LENGTH1(X)
    The graph contains the following edges 1 > 1

  • LENGTH1(mark(X)) → LENGTH1(X)
    The graph contains the following edges 1 > 1

(9) TRUE

(10) Obligation:

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

LENGTH(active(X)) → LENGTH(X)
LENGTH(mark(X)) → LENGTH(X)

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(11) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(12) Obligation:

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

LENGTH(active(X)) → LENGTH(X)
LENGTH(mark(X)) → LENGTH(X)

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

(13) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • LENGTH(active(X)) → LENGTH(X)
    The graph contains the following edges 1 > 1

  • LENGTH(mark(X)) → LENGTH(X)
    The graph contains the following edges 1 > 1

(14) TRUE

(15) Obligation:

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

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

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(16) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(17) Obligation:

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

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

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

(18) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • S(active(X)) → S(X)
    The graph contains the following edges 1 > 1

  • S(mark(X)) → S(X)
    The graph contains the following edges 1 > 1

(19) TRUE

(20) Obligation:

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

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

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(21) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(22) Obligation:

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

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

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

(23) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • CONS(X1, mark(X2)) → CONS(X1, X2)
    The graph contains the following edges 1 >= 1, 2 > 2

  • CONS(mark(X1), X2) → CONS(X1, X2)
    The graph contains the following edges 1 > 1, 2 >= 2

  • CONS(active(X1), X2) → CONS(X1, X2)
    The graph contains the following edges 1 > 1, 2 >= 2

  • CONS(X1, active(X2)) → CONS(X1, X2)
    The graph contains the following edges 1 >= 1, 2 > 2

(24) TRUE

(25) Obligation:

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

FROM(active(X)) → FROM(X)
FROM(mark(X)) → FROM(X)

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(26) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(27) Obligation:

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

FROM(active(X)) → FROM(X)
FROM(mark(X)) → FROM(X)

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

(28) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • FROM(active(X)) → FROM(X)
    The graph contains the following edges 1 > 1

  • FROM(mark(X)) → FROM(X)
    The graph contains the following edges 1 > 1

(29) TRUE

(30) Obligation:

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

MARK(from(X)) → ACTIVE(from(mark(X)))
ACTIVE(from(X)) → MARK(cons(X, from(s(X))))
MARK(from(X)) → MARK(X)
MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(s(X)) → ACTIVE(s(mark(X)))
ACTIVE(length1(X)) → MARK(length(X))
MARK(s(X)) → MARK(X)
MARK(length(X)) → ACTIVE(length(X))
MARK(length1(X)) → ACTIVE(length1(X))

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(31) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(cons(X1, X2)) → ACTIVE(cons(mark(X1), X2))
MARK(s(X)) → ACTIVE(s(mark(X)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:

POL(MARK(x1)) =
/1\
\1/
 +
/00\
\00/
·x1

POL(from(x1)) =
/1\
\1/
 +
/00\
\00/
·x1

POL(ACTIVE(x1)) =
/0\
\0/
 +
/01\
\01/
·x1

POL(mark(x1)) =
/1\
\0/
 +
/11\
\00/
·x1

POL(cons(x1, x2)) =
/1\
\0/
 +
/00\
\00/
·x1 +
/11\
\00/
·x2

POL(s(x1)) =
/1\
\0/
 +
/00\
\00/
·x1

POL(length(x1)) =
/0\
\1/
 +
/00\
\00/
·x1

POL(length1(x1)) =
/1\
\1/
 +
/11\
\00/
·x1

POL(active(x1)) =
/0\
\0/
 +
/00\
\11/
·x1

POL(0) =
/0\
\0/

POL(nil) =
/1\
\0/

The following usable rules [FROCOS05] were oriented:

length1(active(X)) → length1(X)
length1(mark(X)) → length1(X)
length(active(X)) → length(X)
length(mark(X)) → length(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
from(active(X)) → from(X)
from(mark(X)) → from(X)

(32) Obligation:

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

MARK(from(X)) → ACTIVE(from(mark(X)))
ACTIVE(from(X)) → MARK(cons(X, from(s(X))))
MARK(from(X)) → MARK(X)
ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
MARK(cons(X1, X2)) → MARK(X1)
ACTIVE(length1(X)) → MARK(length(X))
MARK(s(X)) → MARK(X)
MARK(length(X)) → ACTIVE(length(X))
MARK(length1(X)) → ACTIVE(length1(X))

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(33) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(from(X)) → MARK(cons(X, from(s(X))))
MARK(from(X)) → MARK(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(ACTIVE(x1)) = x1   
POL(MARK(x1)) = x1   
POL(active(x1)) = x1   
POL(cons(x1, x2)) = x1   
POL(from(x1)) = 1 + x1   
POL(length(x1)) = 0   
POL(length1(x1)) = 0   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   

The following usable rules [FROCOS05] were oriented:

length1(active(X)) → length1(X)
length1(mark(X)) → length1(X)
length(active(X)) → length(X)
length(mark(X)) → length(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)
cons(X1, active(X2)) → cons(X1, X2)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
from(active(X)) → from(X)
from(mark(X)) → from(X)
mark(0) → active(0)
mark(nil) → active(nil)
active(from(X)) → mark(cons(X, from(s(X))))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
active(length1(X)) → mark(length(X))
mark(s(X)) → active(s(mark(X)))
active(length(cons(X, Y))) → mark(s(length1(Y)))
mark(from(X)) → active(from(mark(X)))
mark(length1(X)) → active(length1(X))
mark(length(X)) → active(length(X))
active(length(nil)) → mark(0)

(34) Obligation:

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

MARK(from(X)) → ACTIVE(from(mark(X)))
ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
MARK(cons(X1, X2)) → MARK(X1)
ACTIVE(length1(X)) → MARK(length(X))
MARK(s(X)) → MARK(X)
MARK(length(X)) → ACTIVE(length(X))
MARK(length1(X)) → ACTIVE(length1(X))

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(35) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(from(X)) → ACTIVE(from(mark(X)))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(ACTIVE(x1)) = 0   
POL(MARK(x1)) = x1   
POL(active(x1)) = x1   
POL(cons(x1, x2)) = x1   
POL(from(x1)) = 1   
POL(length(x1)) = 0   
POL(length1(x1)) = 0   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   

The following usable rules [FROCOS05] were oriented:

length1(active(X)) → length1(X)
length1(mark(X)) → length1(X)
length(active(X)) → length(X)
length(mark(X)) → length(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)

(36) Obligation:

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

ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
MARK(cons(X1, X2)) → MARK(X1)
ACTIVE(length1(X)) → MARK(length(X))
MARK(s(X)) → MARK(X)
MARK(length(X)) → ACTIVE(length(X))
MARK(length1(X)) → ACTIVE(length1(X))

The TRS R consists of the following rules:

active(from(X)) → mark(cons(X, from(s(X))))
active(length(nil)) → mark(0)
active(length(cons(X, Y))) → mark(s(length1(Y)))
active(length1(X)) → mark(length(X))
mark(from(X)) → active(from(mark(X)))
mark(cons(X1, X2)) → active(cons(mark(X1), X2))
mark(s(X)) → active(s(mark(X)))
mark(length(X)) → active(length(X))
mark(nil) → active(nil)
mark(0) → active(0)
mark(length1(X)) → active(length1(X))
from(mark(X)) → from(X)
from(active(X)) → from(X)
cons(mark(X1), X2) → cons(X1, X2)
cons(X1, mark(X2)) → cons(X1, X2)
cons(active(X1), X2) → cons(X1, X2)
cons(X1, active(X2)) → cons(X1, X2)
s(mark(X)) → s(X)
s(active(X)) → s(X)
length(mark(X)) → length(X)
length(active(X)) → length(X)
length1(mark(X)) → length1(X)
length1(active(X)) → length1(X)

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

(37) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(38) Obligation:

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

ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
MARK(cons(X1, X2)) → MARK(X1)
ACTIVE(length1(X)) → MARK(length(X))
MARK(s(X)) → MARK(X)
MARK(length(X)) → ACTIVE(length(X))
MARK(length1(X)) → ACTIVE(length1(X))

The TRS R consists of the following rules:

length1(active(X)) → length1(X)
length1(mark(X)) → length1(X)
length(active(X)) → length(X)
length(mark(X)) → length(X)
s(active(X)) → s(X)
s(mark(X)) → s(X)

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

(39) UsableRulesReductionPairsProof (EQUIVALENT transformation)

By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

ACTIVE(length(cons(X, Y))) → MARK(s(length1(Y)))
MARK(cons(X1, X2)) → MARK(X1)
MARK(s(X)) → MARK(X)
The following rules are removed from R:

length1(active(X)) → length1(X)
length1(mark(X)) → length1(X)
length(active(X)) → length(X)
length(mark(X)) → length(X)
s(mark(X)) → s(X)
s(active(X)) → s(X)
Used ordering: POLO with Polynomial interpretation [POLO]:

POL(ACTIVE(x1)) = x1   
POL(MARK(x1)) = x1   
POL(active(x1)) = 2·x1   
POL(cons(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(length(x1)) = 2·x1   
POL(length1(x1)) = 2·x1   
POL(mark(x1)) = 2·x1   
POL(s(x1)) = 1 + x1   

(40) Obligation:

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

ACTIVE(length1(X)) → MARK(length(X))
MARK(length(X)) → ACTIVE(length(X))
MARK(length1(X)) → ACTIVE(length1(X))

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

(41) DependencyGraphProof (EQUIVALENT transformation)

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

(42) TRUE