MAYBE Termination proof of ../tpdb/TRS/CSR_Maude/lazy-nat-list/OvConsOS_nosorts.trs
Termination of the following Term Rewriting System could not be shown:

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

zeros → cons(0, zeros)
and(tt, X) → X
length(nil) → 0
length(cons(N, L)) → s(length(L))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, take(M, IL))

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
and: {1}
tt: empty set
length: {1}
nil: empty set
s: {1}
take: {1, 2}


↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zeros)
and(tt, X) → X
length(nil) → 0
length(cons(N, L)) → s(length(L))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, take(M, IL))

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
and: {1}
tt: empty set
length: {1}
nil: empty set
s: {1}
take: {1, 2}

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
and(tt, X) → a(X)
length(nil) → 0
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.

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

zeros → cons(0, zerosInact)
and(tt, X) → a(X)
length(nil) → 0
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

and(tt, X) → a(X)
length(nil) → 0
a(x) → x
zeros → zerosInact
take(x1, x2) → takeInact(x1, x2)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(a(x1)) = 1 + x1   
POL(and(x1, x2)) = 2 + 2·x1 + x2   
POL(cons(x1, x2)) = 1 + x1 + x2   
POL(length(x1)) = 2 + 2·x1   
POL(nil) = 1   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + 2·x1 + x2   
POL(takeInact(x1, x2)) = 2·x1 + x2   
POL(tt) = 1   
POL(zeros) = 1   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

take(0, IL) → nil
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = 2·x1   
POL(nil) = 1   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2 + 2·x1 + x2   
POL(takeInact(x1, x2)) = 2 + 2·x1 + x2   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.

The TRS is overlay and locally confluent. By [19] we can switch to innermost.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))


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(s(M), cons(N, IL)) → A(IL)
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → LENGTH(a(L))
A(takeInact(x1, x2)) → TAKE(x1, x2)
A(zerosInact) → ZEROS

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → LENGTH(a(L))
A(takeInact(x1, x2)) → TAKE(x1, x2)
A(zerosInact) → ZEROS

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
A(takeInact(x1, x2)) → TAKE(x1, x2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
A(takeInact(x1, x2)) → TAKE(x1, x2)

R is empty.
The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
A(takeInact(x1, x2)) → TAKE(x1, x2)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)

The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros
length(cons(x0, x1))
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

length(cons(x0, x1))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(x1, x2)
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] 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.

No dependency pairs are removed.

The following rules are removed from R:

a(takeInact(x1, x2)) → take(x1, x2)
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTH(x1)) = x1   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = x1 + 2·x2   
POL(s(x1)) = 2 + 2·x1   
POL(take(x1, x2)) = 2·x1 + x2   
POL(takeInact(x1, x2)) = 1 + 2·x1 + x2   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros
take(s(x0), cons(x1, x2))
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

take(s(x0), cons(x1, x2))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule LENGTH(cons(N, L)) → LENGTH(a(L)) at position [0] we obtained the following new rules:

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)

The TRS R consists of the following rules:

a(zerosInact) → zeros
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros
a(zerosInact)
a(takeInact(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

a(zerosInact)
a(takeInact(x0, x1))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule LENGTH(cons(y0, zerosInact)) → LENGTH(zeros) at position [0] we obtained the following new rules:

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))

R is empty.
The set Q consists of the following terms:

zeros

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

zeros



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Instantiation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact)) we obtained the following new rules:

LENGTH(cons(0, zerosInact)) → LENGTH(cons(0, zerosInact))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ Overlay + Local Confluence
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Instantiation
                                                                      ↳ QDP
                                                                        ↳ NonTerminationProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(0, zerosInact)) → LENGTH(cons(0, zerosInact))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

LENGTH(cons(0, zerosInact)) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:none


s = LENGTH(cons(0, zerosInact)) evaluates to t =LENGTH(cons(0, zerosInact))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from LENGTH(cons(0, zerosInact)) to LENGTH(cons(0, zerosInact)).




We applied the Incomplete Giesl Middeldorp [11] to transform the context-sensitive TRS to an usual TRS.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
andActive(tt, X) → mark(X)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(0, IL) → nil
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
andActive(tt, X) → mark(X)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(0, IL) → nil
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

andActive(tt, X) → mark(X)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(and(x1, x2)) = 2·x1 + x2   
POL(andActive(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = x1 + x2   
POL(takeActive(x1, x2)) = x1 + x2   
POL(tt) = 2   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(0, IL) → nil
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(0, IL) → nil
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

takeActive(0, IL) → nil
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(and(x1, x2)) = x1 + 2·x2   
POL(andActive(x1, x2)) = x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2 + x1 + 2·x2   
POL(takeActive(x1, x2)) = 2 + x1 + 2·x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

lengthActive(nil) → 0
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(and(x1, x2)) = 2·x1 + x2   
POL(andActive(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 1   
POL(s(x1)) = 2·x1   
POL(take(x1, x2)) = x1 + x2   
POL(takeActive(x1, x2)) = x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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:

MARK(take(x1, x2)) → MARK(x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(zeros) → ZEROSACTIVE
MARK(take(x1, x2)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
LENGTHACTIVE(cons(N, L)) → MARK(L)
TAKEACTIVE(s(M), cons(N, IL)) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(take(x1, x2)) → MARK(x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(zeros) → ZEROSACTIVE
MARK(take(x1, x2)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
LENGTHACTIVE(cons(N, L)) → MARK(L)
TAKEACTIVE(s(M), cons(N, IL)) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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 2 less nodes.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(take(x1, x2)) → MARK(x2)
MARK(s(x1)) → MARK(x1)
MARK(and(x1, x2)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))
TAKEACTIVE(s(M), cons(N, IL)) → MARK(N)
LENGTHACTIVE(cons(N, L)) → MARK(L)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(length(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

MARK(take(x1, x2)) → MARK(x2)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)


Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = 2·x1   
POL(MARK(x1)) = 2·x1   
POL(TAKEACTIVE(x1, x2)) = 2·x1 + 2·x2   
POL(and(x1, x2)) = 2·x1 + 2·x2   
POL(andActive(x1, x2)) = 2·x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 2   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + 2·x1 + x2   
POL(takeActive(x1, x2)) = 1 + 2·x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(and(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
LENGTHACTIVE(cons(N, L)) → MARK(L)
TAKEACTIVE(s(M), cons(N, IL)) → MARK(N)
MARK(length(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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 1 less node.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(s(x1)) → MARK(x1)
MARK(and(x1, x2)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → MARK(L)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)
MARK(length(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

LENGTHACTIVE(cons(N, L)) → MARK(L)
MARK(length(x1)) → MARK(x1)


Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = 2 + 2·x1   
POL(MARK(x1)) = 2·x1   
POL(and(x1, x2)) = x1 + x2   
POL(andActive(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = x1 + x2   
POL(length(x1)) = 1 + 2·x1   
POL(lengthActive(x1)) = 1 + 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2·x1 + 2·x2   
POL(takeActive(x1, x2)) = 2·x1 + 2·x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(and(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(cons(x1, x2)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                            ↳ Narrowing
                                          ↳ QDP
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule LENGTHACTIVE(cons(N, L)) → LENGTHACTIVE(mark(L)) at position [0] we obtained the following new rules:

LENGTHACTIVE(cons(y0, and(x0, x1))) → LENGTHACTIVE(andActive(mark(x0), x1))
LENGTHACTIVE(cons(y0, tt)) → LENGTHACTIVE(tt)
LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, nil)) → LENGTHACTIVE(nil)
LENGTHACTIVE(cons(y0, length(x0))) → LENGTHACTIVE(lengthActive(mark(x0)))
LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))
LENGTHACTIVE(cons(y0, 0)) → LENGTHACTIVE(0)
LENGTHACTIVE(cons(y0, s(x0))) → LENGTHACTIVE(s(mark(x0)))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ DependencyGraphProof
                                          ↳ QDP
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTHACTIVE(cons(y0, tt)) → LENGTHACTIVE(tt)
LENGTHACTIVE(cons(y0, and(x0, x1))) → LENGTHACTIVE(andActive(mark(x0), x1))
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, 0)) → LENGTHACTIVE(0)
LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))
LENGTHACTIVE(cons(y0, length(x0))) → LENGTHACTIVE(lengthActive(mark(x0)))
LENGTHACTIVE(cons(y0, nil)) → LENGTHACTIVE(nil)
LENGTHACTIVE(cons(y0, s(x0))) → LENGTHACTIVE(s(mark(x0)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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 4 less nodes.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ DependencyGraphProof
                                                  ↳ QDP
                                                    ↳ RuleRemovalProof
                                          ↳ QDP
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTHACTIVE(cons(y0, and(x0, x1))) → LENGTHACTIVE(andActive(mark(x0), x1))
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))
LENGTHACTIVE(cons(y0, length(x0))) → LENGTHACTIVE(lengthActive(mark(x0)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

LENGTHACTIVE(cons(y0, and(x0, x1))) → LENGTHACTIVE(andActive(mark(x0), x1))


Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = 2·x1   
POL(and(x1, x2)) = 1 + x1 + 2·x2   
POL(andActive(x1, x2)) = 1 + x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = 2·x1   
POL(take(x1, x2)) = x1 + x2   
POL(takeActive(x1, x2)) = x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ DependencyGraphProof
                                                  ↳ QDP
                                                    ↳ RuleRemovalProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
                                          ↳ QDP
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, length(x0))) → LENGTHACTIVE(lengthActive(mark(x0)))
LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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.


LENGTHACTIVE(cons(y0, length(x0))) → LENGTHACTIVE(lengthActive(mark(x0)))
The remaining pairs can at least be oriented weakly.

LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(and(x1, x2)) = 1   
POL(andActive(x1, x2)) = 1   
POL(cons(x1, x2)) = 1   
POL(length(x1)) = 0   
POL(lengthActive(x1)) = 0   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 1   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 1   

The following usable rules [17] were oriented:

andActive(x1, x2) → and(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
mark(s(x1)) → s(mark(x1))
takeActive(x1, x2) → take(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
lengthActive(x1) → length(x1)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ DependencyGraphProof
                                                  ↳ QDP
                                                    ↳ RuleRemovalProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
                                                          ↳ QDP
                                                            ↳ QDPOrderProof
                                          ↳ QDP
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

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.


LENGTHACTIVE(cons(y0, cons(x0, x1))) → LENGTHACTIVE(cons(mark(x0), x1))
The remaining pairs can at least be oriented weakly.

LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(and(x1, x2)) = 1 + x2   
POL(andActive(x1, x2)) = 1 + x2   
POL(cons(x1, x2)) = 1 + x2   
POL(length(x1)) = 0   
POL(lengthActive(x1)) = 1   
POL(mark(x1)) = 1 + x1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 0   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 1   

The following usable rules [17] were oriented:

andActive(x1, x2) → and(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
mark(s(x1)) → s(mark(x1))
mark(length(x1)) → lengthActive(mark(x1))
takeActive(x1, x2) → take(x1, x2)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
lengthActive(x1) → length(x1)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                            ↳ Narrowing
                                              ↳ QDP
                                                ↳ DependencyGraphProof
                                                  ↳ QDP
                                                    ↳ RuleRemovalProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
                                                          ↳ QDP
                                                            ↳ QDPOrderProof
                                                              ↳ QDP
                                                                ↳ NonTerminationProof
                                          ↳ QDP
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(y0, take(x0, x1))) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))


s = LENGTHACTIVE(zerosActive) evaluates to t =LENGTHACTIVE(zerosActive)

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

LENGTHACTIVE(zerosActive) → LENGTHACTIVE(cons(0, zeros))
with rule zerosActive → cons(0, zeros) at position [0] and matcher [ ]

LENGTHACTIVE(cons(0, zeros)) → LENGTHACTIVE(zerosActive)
with rule LENGTHACTIVE(cons(y0, zeros)) → LENGTHACTIVE(zerosActive)

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.





↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                          ↳ QDP
                                            ↳ UsableRulesProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(s(x1)) → MARK(x1)
MARK(and(x1, x2)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
lengthActive(cons(N, L)) → s(lengthActive(mark(L)))
takeActive(s(M), cons(N, IL)) → cons(mark(N), take(M, IL))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ RuleRemovalProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ RuleRemovalProof
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ AND
                                          ↳ QDP
                                          ↳ QDP
                                            ↳ UsableRulesProof
                                              ↳ QDP
                                                ↳ QDPSizeChangeProof
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(and(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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:


We applied the Improved Ferreira Ribeiro [5,11] to transform the context-sensitive TRS to an usual TRS.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
and(tt, X) → a(X)
length(nil) → 0
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.

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

zeros → cons(0, zerosInact)
and(tt, X) → a(X)
length(nil) → 0
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

and(tt, X) → a(X)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(a(x1)) = x1   
POL(and(x1, x2)) = 1 + 2·x1 + x2   
POL(cons(x1, x2)) = x1 + x2   
POL(length(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = x1 + 2·x2   
POL(takeInact(x1, x2)) = x1 + 2·x2   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
length(nil) → 0
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.

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

zeros → cons(0, zerosInact)
length(nil) → 0
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

length(nil) → 0
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = 2 + 2·x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2·x1 + x2   
POL(takeInact(x1, x2)) = 2·x1 + x2   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(0, IL) → nil
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

take(0, IL) → nil
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(takeInact(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

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(s(M), cons(N, IL)) → A(IL)
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → LENGTH(a(L))
A(takeInact(x1, x2)) → A(x1)
A(zerosInact) → ZEROS
A(takeInact(x1, x2)) → A(x2)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → LENGTH(a(L))
A(takeInact(x1, x2)) → A(x1)
A(zerosInact) → ZEROS
A(takeInact(x1, x2)) → A(x2)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
A(takeInact(x1, x2)) → A(x1)
A(takeInact(x1, x2)) → A(x2)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                          ↳ QDP
  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → A(IL)
A(takeInact(x1, x2)) → A(x1)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))
A(takeInact(x1, x2)) → A(x2)

The TRS R consists of the following rules:

a(x) → x
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)
zeros → zerosInact

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] 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:

TAKE(s(M), cons(N, IL)) → A(IL)
The following rules are removed from R:

take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(A(x1)) = 1 + x1   
POL(TAKE(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(s(x1)) = 2 + 2·x1   
POL(take(x1, x2)) = 2·x1 + 2·x2   
POL(takeInact(x1, x2)) = 2·x1 + 2·x2   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                          ↳ QDP
  ↳ Complete Giesl Middeldorp-Transformation

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

A(takeInact(x1, x2)) → A(x1)
A(takeInact(x1, x2)) → A(x2)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The TRS R consists of the following rules:

a(x) → x
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)
zeros → zerosInact

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 1 less node.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ UsableRulesProof
                          ↳ QDP
  ↳ Complete Giesl Middeldorp-Transformation

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

A(takeInact(x1, x2)) → A(x1)
A(takeInact(x1, x2)) → A(x2)

The TRS R consists of the following rules:

a(x) → x
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)
zeros → zerosInact

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QDPSizeChangeProof
                          ↳ QDP
  ↳ Complete Giesl Middeldorp-Transformation

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

A(takeInact(x1, x2)) → A(x1)
A(takeInact(x1, x2)) → A(x2)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
length(cons(N, L)) → s(length(a(L)))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(x) → x
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)
zeros → zerosInact

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] 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.

No dependency pairs are removed.

The following rules are removed from R:

take(s(M), cons(N, IL)) → cons(N, takeInact(M, a(IL)))
Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTH(x1)) = x1   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = x1 + 2·x2   
POL(s(x1)) = 2·x1   
POL(take(x1, x2)) = x1 + x2   
POL(takeInact(x1, x2)) = x1 + x2   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(x) → x
a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)
zeros → zerosInact

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

a(x) → x
zeros → zerosInact

Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTH(x1)) = x1   
POL(a(x1)) = 1 + 2·x1   
POL(cons(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(take(x1, x2)) = 2 + x1 + 2·x2   
POL(takeInact(x1, x2)) = 2 + x1 + 2·x2   
POL(zeros) = 1   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [15] to enlarge Q to all left-hand sides of R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
a(takeInact(x1, x2)) → take(a(x1), a(x2))
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

a(zerosInact)
a(takeInact(x0, x1))
take(x0, x1)
zeros

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

a(takeInact(x1, x2)) → take(a(x1), a(x2))

Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTH(x1)) = x1   
POL(a(x1)) = 2·x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(take(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(takeInact(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
take(x1, x2) → takeInact(x1, x2)
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

a(zerosInact)
a(takeInact(x0, x1))
take(x0, x1)
zeros

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

a(zerosInact)
a(takeInact(x0, x1))
take(x0, x1)
zeros

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

take(x0, x1)



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → LENGTH(a(L))

The TRS R consists of the following rules:

a(zerosInact) → zeros
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

a(zerosInact)
a(takeInact(x0, x1))
zeros

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule LENGTH(cons(N, L)) → LENGTH(a(L)) at position [0] we obtained the following new rules:

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)

The TRS R consists of the following rules:

a(zerosInact) → zeros
zeros → cons(0, zerosInact)

The set Q consists of the following terms:

a(zerosInact)
a(takeInact(x0, x1))
zeros

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)

The set Q consists of the following terms:

a(zerosInact)
a(takeInact(x0, x1))
zeros

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

a(zerosInact)
a(takeInact(x0, x1))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(zeros)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule LENGTH(cons(y0, zerosInact)) → LENGTH(zeros) at position [0] we obtained the following new rules:

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)

The set Q consists of the following terms:

zeros

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))

R is empty.
The set Q consists of the following terms:

zeros

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

zeros



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
                                                                              ↳ QDP
                                                                                ↳ Instantiation
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule LENGTH(cons(y0, zerosInact)) → LENGTH(cons(0, zerosInact)) we obtained the following new rules:

LENGTH(cons(0, zerosInact)) → LENGTH(cons(0, zerosInact))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
                                    ↳ RuleRemovalProof
                                      ↳ QDP
                                        ↳ MNOCProof
                                          ↳ QDP
                                            ↳ RuleRemovalProof
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Narrowing
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
                                                                              ↳ QDP
                                                                                ↳ Instantiation
                                                                                  ↳ QDP
                                                                                    ↳ NonTerminationProof
  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(0, zerosInact)) → LENGTH(cons(0, zerosInact))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

LENGTH(cons(0, zerosInact)) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:none


s = LENGTH(cons(0, zerosInact)) evaluates to t =LENGTH(cons(0, zerosInact))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from LENGTH(cons(0, zerosInact)) to LENGTH(cons(0, zerosInact)).




We applied the Complete Giesl Middeldorp [11] to transform the context-sensitive TRS to an usual TRS.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof

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

active(zeros) → mark(cons(0, zeros))
active(and(tt, X)) → mark(X)
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(s(length(L)))
active(take(0, IL)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))


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

active(zeros) → mark(cons(0, zeros))
active(and(tt, X)) → mark(X)
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(s(length(L)))
active(take(0, IL)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

active(and(tt, X)) → mark(X)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(active(x1)) = x1   
POL(and(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = x1 + 2·x2   
POL(length(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(ok(x1)) = x1   
POL(proper(x1)) = x1   
POL(s(x1)) = 2·x1   
POL(take(x1, x2)) = x1 + x2   
POL(top(x1)) = 2·x1   
POL(tt) = 1   
POL(zeros) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof

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

active(zeros) → mark(cons(0, zeros))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(s(length(L)))
active(take(0, IL)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))


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

active(zeros) → mark(cons(0, zeros))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(s(length(L)))
active(take(0, IL)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

active(length(nil)) → mark(0)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(active(x1)) = x1   
POL(and(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 1   
POL(ok(x1)) = x1   
POL(proper(x1)) = x1   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(top(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof

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

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(0, IL)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))


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

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(0, IL)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

The following rules can be removed by the rule removal processor [15] because they are oriented strictly by a polynomial ordering:

active(take(0, IL)) → mark(nil)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(active(x1)) = x1   
POL(and(x1, x2)) = x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(length(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(ok(x1)) = x1   
POL(proper(x1)) = x1   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(top(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof

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

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))


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

AND(ok(x1), ok(x2)) → AND(x1, x2)
TOP(mark(x)) → PROPER(x)
ACTIVE(zeros) → CONS(0, zeros)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
PROPER(and(x1, x2)) → PROPER(x1)
LENGTH(ok(x1)) → LENGTH(x1)
PROPER(length(x1)) → PROPER(x1)
S(mark(x1)) → S(x1)
ACTIVE(length(cons(N, L))) → LENGTH(L)
PROPER(and(x1, x2)) → AND(proper(x1), proper(x2))
PROPER(take(x1, x2)) → PROPER(x2)
ACTIVE(take(s(M), cons(N, IL))) → TAKE(M, IL)
LENGTH(mark(x1)) → LENGTH(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
TOP(mark(x)) → TOP(proper(x))
PROPER(s(x1)) → S(proper(x1))
S(ok(x1)) → S(x1)
ACTIVE(s(x1)) → ACTIVE(x1)
TAKE(mark(x1), x2) → TAKE(x1, x2)
CONS(mark(x1), x2) → CONS(x1, x2)
ACTIVE(cons(x1, x2)) → CONS(active(x1), x2)
ACTIVE(length(cons(N, L))) → S(length(L))
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
ACTIVE(length(x1)) → LENGTH(active(x1))
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)
PROPER(length(x1)) → LENGTH(proper(x1))
TOP(ok(x)) → ACTIVE(x)
PROPER(take(x1, x2)) → PROPER(x1)
ACTIVE(take(x1, x2)) → TAKE(x1, active(x2))
ACTIVE(s(x1)) → S(active(x1))
PROPER(cons(x1, x2)) → CONS(proper(x1), proper(x2))
PROPER(s(x1)) → PROPER(x1)
TOP(ok(x)) → TOP(active(x))
ACTIVE(take(x1, x2)) → ACTIVE(x1)
PROPER(cons(x1, x2)) → PROPER(x2)
ACTIVE(take(x1, x2)) → TAKE(active(x1), x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)
ACTIVE(take(s(M), cons(N, IL))) → CONS(N, take(M, IL))
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(take(x1, x2)) → TAKE(proper(x1), proper(x2))
ACTIVE(and(x1, x2)) → AND(active(x1), x2)
AND(mark(x1), x2) → AND(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof

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

AND(ok(x1), ok(x2)) → AND(x1, x2)
TOP(mark(x)) → PROPER(x)
ACTIVE(zeros) → CONS(0, zeros)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
PROPER(and(x1, x2)) → PROPER(x1)
LENGTH(ok(x1)) → LENGTH(x1)
PROPER(length(x1)) → PROPER(x1)
S(mark(x1)) → S(x1)
ACTIVE(length(cons(N, L))) → LENGTH(L)
PROPER(and(x1, x2)) → AND(proper(x1), proper(x2))
PROPER(take(x1, x2)) → PROPER(x2)
ACTIVE(take(s(M), cons(N, IL))) → TAKE(M, IL)
LENGTH(mark(x1)) → LENGTH(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
TOP(mark(x)) → TOP(proper(x))
PROPER(s(x1)) → S(proper(x1))
S(ok(x1)) → S(x1)
ACTIVE(s(x1)) → ACTIVE(x1)
TAKE(mark(x1), x2) → TAKE(x1, x2)
CONS(mark(x1), x2) → CONS(x1, x2)
ACTIVE(cons(x1, x2)) → CONS(active(x1), x2)
ACTIVE(length(cons(N, L))) → S(length(L))
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
ACTIVE(length(x1)) → LENGTH(active(x1))
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)
PROPER(length(x1)) → LENGTH(proper(x1))
TOP(ok(x)) → ACTIVE(x)
PROPER(take(x1, x2)) → PROPER(x1)
ACTIVE(take(x1, x2)) → TAKE(x1, active(x2))
ACTIVE(s(x1)) → S(active(x1))
PROPER(cons(x1, x2)) → CONS(proper(x1), proper(x2))
PROPER(s(x1)) → PROPER(x1)
TOP(ok(x)) → TOP(active(x))
ACTIVE(take(x1, x2)) → ACTIVE(x1)
PROPER(cons(x1, x2)) → PROPER(x2)
ACTIVE(take(x1, x2)) → TAKE(active(x1), x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)
ACTIVE(take(s(M), cons(N, IL))) → CONS(N, take(M, IL))
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(take(x1, x2)) → TAKE(proper(x1), proper(x2))
ACTIVE(and(x1, x2)) → AND(active(x1), x2)
AND(mark(x1), x2) → AND(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

S(ok(x1)) → S(x1)
S(mark(x1)) → S(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

S(ok(x1)) → S(x1)
S(mark(x1)) → S(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

S(ok(x1)) → S(x1)
S(mark(x1)) → S(x1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

LENGTH(mark(x1)) → LENGTH(x1)
LENGTH(ok(x1)) → LENGTH(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

LENGTH(mark(x1)) → LENGTH(x1)
LENGTH(ok(x1)) → LENGTH(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

LENGTH(ok(x1)) → LENGTH(x1)
LENGTH(mark(x1)) → LENGTH(x1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

CONS(mark(x1), x2) → CONS(x1, x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

CONS(mark(x1), x2) → CONS(x1, x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP

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

CONS(mark(x1), x2) → CONS(x1, x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP
                          ↳ QDP

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

PROPER(take(x1, x2)) → PROPER(x2)
PROPER(take(x1, x2)) → PROPER(x1)
PROPER(and(x1, x2)) → PROPER(x1)
PROPER(s(x1)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x2)
PROPER(and(x1, x2)) → PROPER(x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP
                          ↳ QDP

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

PROPER(take(x1, x2)) → PROPER(x2)
PROPER(take(x1, x2)) → PROPER(x1)
PROPER(and(x1, x2)) → PROPER(x1)
PROPER(s(x1)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x2)
PROPER(and(x1, x2)) → PROPER(x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
proper(cons(x0, x1))
proper(0)
active(and(x0, x1))
proper(and(x0, x1))
proper(tt)
active(length(x0))
proper(length(x0))
proper(nil)
active(s(x0))
proper(s(x0))
active(take(x0, x1))
proper(take(x0, x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP

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

PROPER(take(x1, x2)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x2)
PROPER(and(x1, x2)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
PROPER(s(x1)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x2)
PROPER(and(x1, x2)) → PROPER(x2)

R is empty.
The set Q consists of the following terms:

cons(mark(x0), x1)
cons(ok(x0), ok(x1))
and(mark(x0), x1)
and(ok(x0), ok(x1))
length(mark(x0))
length(ok(x0))
s(mark(x0))
s(ok(x0))
take(mark(x0), x1)
take(x0, mark(x1))
take(ok(x0), ok(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                          ↳ QDP

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

ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                          ↳ QDP

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

ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
proper(zeros)
active(cons(x0, x1))
proper(cons(x0, x1))
proper(0)
active(and(x0, x1))
proper(and(x0, x1))
proper(tt)
active(length(x0))
proper(length(x0))
proper(nil)
active(s(x0))
proper(s(x0))
active(take(x0, x1))
proper(take(x0, x1))
top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ QDPSizeChangeProof
                          ↳ QDP

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

ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)

R is empty.
The set Q consists of the following terms:

cons(mark(x0), x1)
cons(ok(x0), ok(x1))
and(mark(x0), x1)
and(ok(x0), ok(x1))
length(mark(x0))
length(ok(x0))
s(mark(x0))
s(ok(x0))
take(mark(x0), x1)
take(x0, mark(x1))
take(ok(x0), ok(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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: 



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof

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(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(tt) → ok(tt)
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
proper(nil) → ok(nil)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof

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:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

top(mark(x0))
top(ok(x0))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing

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:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule TOP(ok(x)) → TOP(active(x)) at position [0] we obtained the following new rules:

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(ok(length(x0))) → TOP(length(active(x0)))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ Narrowing

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(x)) → TOP(proper(x))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(ok(length(x0))) → TOP(length(active(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule TOP(mark(x)) → TOP(proper(x)) at position [0] we obtained the following new rules:

TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(nil)) → TOP(ok(nil))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(0)) → TOP(ok(0))
TOP(mark(tt)) → TOP(ok(tt))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(mark(tt)) → TOP(ok(tt))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(mark(nil)) → TOP(ok(nil))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(0)) → TOP(ok(0))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

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

↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

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.


TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
The remaining pairs can at least be oriented weakly.

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(TOP(x1)) = x1   
POL(active(x1)) = 1   
POL(and(x1, x2)) = 0   
POL(cons(x1, x2)) = 0   
POL(length(x1)) = 0   
POL(mark(x1)) = 0   
POL(nil) = 0   
POL(ok(x1)) = x1   
POL(proper(x1)) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 0   
POL(tt) = 0   
POL(zeros) = 1   

The following usable rules [17] were oriented:

s(ok(x1)) → ok(s(x1))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
length(mark(x1)) → mark(length(x1))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
s(mark(x1)) → mark(s(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

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.


TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(cons(x1, take(x0, x2))))
The remaining pairs can at least be oriented weakly.

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(TOP(x1)) = x1   
POL(active(x1)) = 0   
POL(and(x1, x2)) = 0   
POL(cons(x1, x2)) = 0   
POL(length(x1)) = 0   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(ok(x1)) = x1   
POL(proper(x1)) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 1   
POL(tt) = 0   
POL(zeros) = 0   

The following usable rules [17] were oriented:

s(ok(x1)) → ok(s(x1))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
length(mark(x1)) → mark(length(x1))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
s(mark(x1)) → mark(s(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

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.


TOP(ok(length(cons(x0, x1)))) → TOP(mark(s(length(x1))))
The remaining pairs can at least be oriented weakly.

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(TOP(x1)) = x1   
POL(active(x1)) = x1   
POL(and(x1, x2)) = 0   
POL(cons(x1, x2)) = 1   
POL(length(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(ok(x1)) = x1   
POL(proper(x1)) = x1   
POL(s(x1)) = 0   
POL(take(x1, x2)) = x2   
POL(tt) = 0   
POL(zeros) = 1   

The following usable rules [17] were oriented:

proper(length(x1)) → length(proper(x1))
active(and(x1, x2)) → and(active(x1), x2)
s(ok(x1)) → ok(s(x1))
active(length(cons(N, L))) → mark(s(length(L)))
proper(0) → ok(0)
and(mark(x1), x2) → mark(and(x1, x2))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(length(x1)) → length(active(x1))
length(ok(x1)) → ok(length(x1))
active(take(x1, x2)) → take(active(x1), x2)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
active(cons(x1, x2)) → cons(active(x1), x2)
length(mark(x1)) → mark(length(x1))
proper(tt) → ok(tt)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
active(zeros) → mark(cons(0, zeros))
proper(nil) → ok(nil)
s(mark(x1)) → mark(s(x1))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(x1, active(x2))
proper(s(x1)) → s(proper(x1))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(zeros) → ok(zeros)
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))



↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Improved Ferreira Ribeiro-Transformation
  ↳ Complete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ DependencyPairsProof
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ UsableRulesProof
                              ↳ QDP
                                ↳ QReductionProof
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
                                                          ↳ QDP

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(length(x1)) → length(proper(x1))
proper(nil) → ok(nil)
proper(s(x1)) → s(proper(x1))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(length(cons(N, L))) → mark(s(length(L)))
active(take(s(M), cons(N, IL))) → mark(cons(N, take(M, IL)))
active(cons(x1, x2)) → cons(active(x1), x2)
active(and(x1, x2)) → and(active(x1), x2)
active(length(x1)) → length(active(x1))
active(s(x1)) → s(active(x1))
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))

The set Q consists of the following terms:

active(zeros)
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(tt)
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
proper(nil)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))

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