YES Termination proof of ../tpdb/TRS/CSR_Maude/length-lazy-list/LengthOfFiniteLists_nokinds-noand.trs
Termination of the following Term Rewriting System could be proven:

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

zeros → cons(0, zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(V2))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(V2))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(N), L)
U62(tt, L) → s(length(L))
isNat(0) → tt
isNat(length(V1)) → U11(isNatList(V1))
isNat(s(V1)) → U21(isNat(V1))
isNatIList(V) → U31(isNatList(V))
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(isNat(V1), V2)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(isNat(V1), V2)
length(nil) → 0
length(cons(N, L)) → U61(isNatList(L), L, N)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U21: {1}
U31: {1}
U41: {1}
U42: {1}
isNatIList: empty set
U51: {1}
U52: {1}
isNatList: empty set
U61: {1}
U62: {1}
isNat: empty set
s: {1}
length: {1}
nil: empty set


↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zeros)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(V2))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(V2))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(N), L)
U62(tt, L) → s(length(L))
isNat(0) → tt
isNat(length(V1)) → U11(isNatList(V1))
isNat(s(V1)) → U21(isNat(V1))
isNatIList(V) → U31(isNatList(V))
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(isNat(V1), V2)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(isNat(V1), V2)
length(nil) → 0
length(cons(N, L)) → U61(isNatList(L), L, N)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U21: {1}
U31: {1}
U41: {1}
U42: {1}
isNatIList: empty set
U51: {1}
U52: {1}
isNatList: empty set
U61: {1}
U62: {1}
isNat: empty set
s: {1}
length: {1}
nil: empty set

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(nil) → 0
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(nil) → 0
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

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

POL(0) = 0   
POL(0Inact) = 0   
POL(U11(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U31(x1)) = x1   
POL(U41(x1, x2)) = 2·x1 + 2·x2   
POL(U42(x1)) = 2·x1   
POL(U51(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 2·x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatIList(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthInact(x1)) = 2·x1   
POL(nil) = 1   
POL(nilInact) = 1   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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)
U11(tt) → tt
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

U11(tt) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(U11(x1)) = 1 + x1   
POL(U21(x1)) = x1   
POL(U31(x1)) = 2·x1   
POL(U41(x1, x2)) = x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = 1 + 2·x1 + 2·x2 + x3   
POL(U62(x1, x2)) = 1 + x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatIList(x1)) = 2·x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 1 + 2·x1   
POL(lengthInact(x1)) = 1 + 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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)
U21(tt) → tt
U31(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

U31(tt) → tt
isNatIList(zerosInact) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(U11(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U31(x1)) = 1 + x1   
POL(U41(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = 2·x1   
POL(isNatIList(x1)) = 1 + 2·x1   
POL(isNatList(x1)) = 2·x1   
POL(length(x1)) = 2·x1   
POL(lengthInact(x1)) = 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

isNat(lengthInact(V1)) → U11(isNatList(a(V1)))
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(U11(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U31(x1)) = 2·x1   
POL(U41(x1, x2)) = 2·x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 1 + 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 1 + x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatIList(x1)) = 2·x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 1 + 2·x1   
POL(lengthInact(x1)) = 1 + 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(V) → U31(isNatList(a(V)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

isNatIList(V) → U31(isNatList(a(V)))
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(U21(x1)) = x1   
POL(U31(x1)) = x1   
POL(U41(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatIList(x1)) = 1 + x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthInact(x1)) = 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   




↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

Q is empty.

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

U621(tt, L) → A(L)
U511(tt, V2) → A(V2)
A(zerosInact) → ZEROS
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → U611(isNatList(a(L)), a(L), N)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
U611(tt, L, N) → ISNAT(a(N))
A(lengthInact(x1)) → LENGTH(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2))
U611(tt, L, N) → U621(isNat(a(N)), a(L))
A(0Inact) → 01
U611(tt, L, N) → A(N)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
U511(tt, V2) → U521(isNatList(a(V2)))
LENGTH(cons(N, L)) → A(L)
U621(tt, L) → LENGTH(a(L))
ISNATILIST(consInact(V1, V2)) → A(V2)
A(sInact(x1)) → S(x1)
ISNAT(sInact(V1)) → A(V1)
ISNAT(sInact(V1)) → U211(isNat(a(V1)))
ISNATLIST(consInact(V1, V2)) → A(V2)
U621(tt, L) → S(length(a(L)))
U611(tt, L, N) → A(L)
U411(tt, V2) → U421(isNatIList(a(V2)))
ISNATILIST(consInact(V1, V2)) → U411(isNat(a(V1)), a(V2))
ZEROS → 01
A(consInact(x1, x2)) → CONS(x1, x2)
U511(tt, V2) → ISNATLIST(a(V2))
U411(tt, V2) → A(V2)
ZEROS → CONS(0, zerosInact)
A(nilInact) → NIL
U411(tt, V2) → ISNATILIST(a(V2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
  ↳ Incomplete Giesl Middeldorp-Transformation

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

U621(tt, L) → A(L)
U511(tt, V2) → A(V2)
A(zerosInact) → ZEROS
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → U611(isNatList(a(L)), a(L), N)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
U611(tt, L, N) → ISNAT(a(N))
A(lengthInact(x1)) → LENGTH(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2))
U611(tt, L, N) → U621(isNat(a(N)), a(L))
A(0Inact) → 01
U611(tt, L, N) → A(N)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
U511(tt, V2) → U521(isNatList(a(V2)))
LENGTH(cons(N, L)) → A(L)
U621(tt, L) → LENGTH(a(L))
ISNATILIST(consInact(V1, V2)) → A(V2)
A(sInact(x1)) → S(x1)
ISNAT(sInact(V1)) → A(V1)
ISNAT(sInact(V1)) → U211(isNat(a(V1)))
ISNATLIST(consInact(V1, V2)) → A(V2)
U621(tt, L) → S(length(a(L)))
U611(tt, L, N) → A(L)
U411(tt, V2) → U421(isNatIList(a(V2)))
ISNATILIST(consInact(V1, V2)) → U411(isNat(a(V1)), a(V2))
ZEROS → 01
A(consInact(x1, x2)) → CONS(x1, x2)
U511(tt, V2) → ISNATLIST(a(V2))
U411(tt, V2) → A(V2)
ZEROS → CONS(0, zerosInact)
A(nilInact) → NIL
U411(tt, V2) → ISNATILIST(a(V2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

U611(tt, L, N) → A(N)
U621(tt, L) → A(L)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → A(L)
U621(tt, L) → LENGTH(a(L))
ISNAT(sInact(V1)) → A(V1)
U511(tt, V2) → A(V2)
ISNATLIST(consInact(V1, V2)) → A(V2)
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → U611(isNatList(a(L)), a(L), N)
U611(tt, L, N) → A(L)
U611(tt, L, N) → ISNAT(a(N))
A(lengthInact(x1)) → LENGTH(x1)
U511(tt, V2) → ISNATLIST(a(V2))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2))
U611(tt, L, N) → U621(isNat(a(N)), a(L))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

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.

No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(A(x1)) = x1   
POL(ISNAT(x1)) = x1   
POL(ISNATLIST(x1)) = x1   
POL(LENGTH(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + x2   
POL(U511(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U611(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 2·x1 + 2·x2   
POL(U621(x1, x2)) = x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthInact(x1)) = 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

U611(tt, L, N) → A(N)
U621(tt, L) → A(L)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → A(L)
U621(tt, L) → LENGTH(a(L))
ISNAT(sInact(V1)) → A(V1)
U511(tt, V2) → A(V2)
ISNATLIST(consInact(V1, V2)) → A(V2)
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → U611(isNatList(a(L)), a(L), N)
U611(tt, L, N) → A(L)
U611(tt, L, N) → ISNAT(a(N))
ISNATLIST(consInact(V1, V2)) → A(V1)
U511(tt, V2) → ISNATLIST(a(V2))
A(lengthInact(x1)) → LENGTH(x1)
ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2))
U611(tt, L, N) → U621(isNat(a(N)), a(L))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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:

A(lengthInact(x1)) → LENGTH(x1)


Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(A(x1)) = 2·x1   
POL(ISNAT(x1)) = 2·x1   
POL(ISNATLIST(x1)) = 2·x1   
POL(LENGTH(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U51(x1, x2)) = x1 + 2·x2   
POL(U511(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 2 + x1 + 2·x2 + 2·x3   
POL(U611(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 2 + x1 + 2·x2   
POL(U621(x1, x2)) = x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = 2·x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 2 + 2·x1   
POL(lengthInact(x1)) = 2 + 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

U611(tt, L, N) → A(N)
U621(tt, L) → A(L)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → A(L)
U621(tt, L) → LENGTH(a(L))
ISNAT(sInact(V1)) → A(V1)
U511(tt, V2) → A(V2)
ISNATLIST(consInact(V1, V2)) → A(V2)
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → U611(isNatList(a(L)), a(L), N)
U611(tt, L, N) → A(L)
U611(tt, L, N) → ISNAT(a(N))
U511(tt, V2) → ISNATLIST(a(V2))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2))
U611(tt, L, N) → U621(isNat(a(N)), a(L))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                ↳ QDP
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNAT(sInact(V1)) → ISNAT(a(V1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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.


ISNAT(sInact(V1)) → ISNAT(a(V1))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(ISNAT(x1)) = x1   
POL(U21(x1)) = 1   
POL(U51(x1, x2)) = 0   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 1 + x1   
POL(U62(x1, x2)) = 1 + x1   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 0   
POL(consInact(x1, x2)) = 0   
POL(isNat(x1)) = 1   
POL(isNatList(x1)) = 0   
POL(length(x1)) = 1   
POL(lengthInact(x1)) = 1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = 1 + x1   
POL(sInact(x1)) = 1 + x1   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosInact) = 0   

The following usable rules [17] were oriented:

a(zerosInact) → zeros
nil → nilInact
isNat(0Inact) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
zeros → zerosInact
a(0Inact) → 0
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
U62(tt, L) → s(length(a(L)))
a(nilInact) → nil
U52(tt) → tt
a(x) → x
length(x1) → lengthInact(x1)
U51(tt, V2) → U52(isNatList(a(V2)))
s(x1) → sInact(x1)
U21(tt) → tt
a(consInact(x1, x2)) → cons(x1, x2)
a(lengthInact(x1)) → length(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
0 → 0Inact
zeros → cons(0, zerosInact)
isNat(sInact(V1)) → U21(isNat(a(V1)))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ PisEmptyProof
                                                ↳ QDP
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

U511(tt, V2) → ISNATLIST(a(V2))
ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISNATLIST(consInact(V1, V2)) → U511(isNat(a(V1)), a(V2)) at position [0] we obtained the following new rules:

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(nilInact, y1)) → U511(isNat(nil), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(nilInact, y1)) → U511(isNat(nil), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, V2) → ISNATLIST(a(V2))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U511(tt, V2) → ISNATLIST(a(V2)) at position [0] we obtained the following new rules:

U511(tt, sInact(x0)) → ISNATLIST(s(x0))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0)
U511(tt, zerosInact) → ISNATLIST(zeros)
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
U511(tt, sInact(x0)) → ISNATLIST(s(x0))
ISNATLIST(consInact(nilInact, y1)) → U511(isNat(nil), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISNATLIST(consInact(nilInact, y1)) → U511(isNat(nil), a(y1)) at position [0] we obtained the following new rules:

ISNATLIST(consInact(nilInact, y0)) → U511(isNat(nilInact), a(y0))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
ISNATLIST(consInact(nilInact, y0)) → U511(isNat(nilInact), a(y0))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
U511(tt, sInact(x0)) → ISNATLIST(s(x0))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
U511(tt, sInact(x0)) → ISNATLIST(s(x0))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U511(tt, sInact(x0)) → ISNATLIST(s(x0)) at position [0] we obtained the following new rules:

U511(tt, sInact(x0)) → ISNATLIST(sInact(x0))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0)
U511(tt, sInact(x0)) → ISNATLIST(sInact(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0)
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U511(tt, 0Inact) → ISNATLIST(0) at position [0] we obtained the following new rules:

U511(tt, 0Inact) → ISNATLIST(0Inact)



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, 0Inact) → ISNATLIST(0Inact)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISNATLIST(consInact(consInact(x0, x1), y1)) → U511(isNat(cons(x0, x1)), a(y1)) at position [0] we obtained the following new rules:

ISNATLIST(consInact(consInact(x0, x1), y2)) → U511(isNat(consInact(x0, x1)), a(y2))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
ISNATLIST(consInact(consInact(x0, x1), y2)) → U511(isNat(consInact(x0, x1)), a(y2))
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, nilInact) → ISNATLIST(nil)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U511(tt, nilInact) → ISNATLIST(nil) at position [0] we obtained the following new rules:

U511(tt, nilInact) → ISNATLIST(nilInact)



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, nilInact) → ISNATLIST(nilInact)
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ RuleRemovalProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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:

ISNATLIST(consInact(lengthInact(x0), y1)) → U511(isNat(length(x0)), a(y1))


Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(ISNATLIST(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U51(x1, x2)) = x1 + x2   
POL(U511(x1, x2)) = x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 1 + x1 + x2 + x3   
POL(U62(x1, x2)) = 1 + x1 + x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = x1 + 2·x2   
POL(consInact(x1, x2)) = x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 1 + x1   
POL(lengthInact(x1)) = 1 + x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ RuleRemovalProof
                                                                                                    ↳ QDP
                                                                                                      ↳ RuleRemovalProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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:

U511(tt, lengthInact(x0)) → ISNATLIST(length(x0))


Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(ISNATLIST(x1)) = x1   
POL(U21(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + 2·x2   
POL(U511(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U61(x1, x2, x3)) = 1 + x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(consInact(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatList(x1)) = 2·x1   
POL(length(x1)) = 1 + 2·x1   
POL(lengthInact(x1)) = 1 + 2·x1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ RuleRemovalProof
                                                                                                    ↳ QDP
                                                                                                      ↳ RuleRemovalProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, zerosInact) → ISNATLIST(zeros)
ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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.


ISNATLIST(consInact(zerosInact, y1)) → U511(isNat(zeros), a(y1))
The remaining pairs can at least be oriented weakly.

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, zerosInact) → ISNATLIST(zeros)
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(ISNATLIST(x1)) = x1   
POL(U21(x1)) = 0   
POL(U51(x1, x2)) = x2   
POL(U511(x1, x2)) = x2   
POL(U52(x1)) = 0   
POL(U61(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = x1 + x2   
POL(consInact(x1, x2)) = x1 + x2   
POL(isNat(x1)) = 0   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 0   
POL(lengthInact(x1)) = 0   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = x1   
POL(sInact(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 1   
POL(zerosInact) = 1   

The following usable rules [17] were oriented:

a(zerosInact) → zeros
nil → nilInact
U61(tt, L, N) → U62(isNat(a(N)), a(L))
zeros → zerosInact
a(0Inact) → 0
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(sInact(x1)) → s(x1)
U62(tt, L) → s(length(a(L)))
cons(x1, x2) → consInact(x1, x2)
a(nilInact) → nil
U52(tt) → tt
a(x) → x
length(x1) → lengthInact(x1)
U51(tt, V2) → U52(isNatList(a(V2)))
U21(tt) → tt
s(x1) → sInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
a(lengthInact(x1)) → length(x1)
0 → 0Inact
zeros → cons(0, zerosInact)
isNat(sInact(V1)) → U21(isNat(a(V1)))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ RuleRemovalProof
                                                                                                    ↳ QDP
                                                                                                      ↳ RuleRemovalProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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.


ISNATLIST(consInact(sInact(x0), y1)) → U511(isNat(s(x0)), a(y1))
The remaining pairs can at least be oriented weakly.

U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, zerosInact) → ISNATLIST(zeros)
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(0Inact) = 0   
POL(ISNATLIST(x1)) = x1   
POL(U21(x1)) = 0   
POL(U51(x1, x2)) = 0   
POL(U511(x1, x2)) = x2   
POL(U52(x1)) = 0   
POL(U61(x1, x2, x3)) = 1   
POL(U62(x1, x2)) = 1   
POL(a(x1)) = x1   
POL(cons(x1, x2)) = x1 + x2   
POL(consInact(x1, x2)) = x1 + x2   
POL(isNat(x1)) = 0   
POL(isNatList(x1)) = x1   
POL(length(x1)) = 1   
POL(lengthInact(x1)) = 1   
POL(nil) = 0   
POL(nilInact) = 0   
POL(s(x1)) = 1   
POL(sInact(x1)) = 1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   

The following usable rules [17] were oriented:

a(zerosInact) → zeros
nil → nilInact
U61(tt, L, N) → U62(isNat(a(N)), a(L))
zeros → zerosInact
a(0Inact) → 0
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(sInact(x1)) → s(x1)
U62(tt, L) → s(length(a(L)))
cons(x1, x2) → consInact(x1, x2)
a(nilInact) → nil
U52(tt) → tt
a(x) → x
length(x1) → lengthInact(x1)
U51(tt, V2) → U52(isNatList(a(V2)))
U21(tt) → tt
s(x1) → sInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
a(lengthInact(x1)) → length(x1)
0 → 0Inact
zeros → cons(0, zerosInact)
isNat(sInact(V1)) → U21(isNat(a(V1)))



↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ RuleRemovalProof
                                                                                                    ↳ QDP
                                                                                                      ↳ RuleRemovalProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QDPOrderProof
                                                                                                            ↳ QDP
                                                                                                              ↳ QDPOrderProof
                                                                                                                ↳ QDP
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(x0, y1)) → U511(isNat(x0), a(y1))
U511(tt, consInact(x0, x1)) → ISNATLIST(cons(x0, x1))
U511(tt, zerosInact) → ISNATLIST(zeros)
U511(tt, x0) → ISNATLIST(x0)
ISNATLIST(consInact(0Inact, y1)) → U511(isNat(0), a(y1))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                    ↳ UsableRulesReductionPairsProof
                                      ↳ QDP
                                        ↳ RuleRemovalProof
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ AND
                                                ↳ QDP
                                                ↳ QDP
                                                ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

U621(tt, L) → LENGTH(a(L))
LENGTH(cons(N, L)) → U611(isNatList(a(L)), a(L), N)
U611(tt, L, N) → U621(isNat(a(N)), a(L))

The TRS R consists of the following rules:

a(x) → x
a(lengthInact(x1)) → length(x1)
a(zerosInact) → zeros
a(0Inact) → 0
a(nilInact) → nil
a(consInact(x1, x2)) → cons(x1, x2)
a(sInact(x1)) → s(x1)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
U21(tt) → tt
s(x1) → sInact(x1)
cons(x1, x2) → consInact(x1, x2)
nil → nilInact
0 → 0Inact
zeros → cons(0, zerosInact)
zeros → zerosInact
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
length(x1) → lengthInact(x1)
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt

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

↳ CSR
  ↳ Zantema-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ DependencyPairsProof
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ AND
                                  ↳ QDP
                                  ↳ QDP
  ↳ Incomplete Giesl Middeldorp-Transformation

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

ISNATILIST(consInact(V1, V2)) → U411(isNat(a(V1)), a(V2))
U411(tt, V2) → ISNATILIST(a(V2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt) → tt
U41(tt, V2) → U42(isNatIList(a(V2)))
U42(tt) → tt
U51(tt, V2) → U52(isNatList(a(V2)))
U52(tt) → tt
U61(tt, L, N) → U62(isNat(a(N)), a(L))
U62(tt, L) → s(length(a(L)))
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNat(a(V1)))
isNatIList(consInact(V1, V2)) → U41(isNat(a(V1)), a(V2))
isNatList(consInact(V1, V2)) → U51(isNat(a(V1)), a(V2))
length(cons(N, L)) → U61(isNatList(a(L)), a(L), N)
a(x) → x
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
nil → nilInact
a(nilInact) → nil
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
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

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U31Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(V) → U31Active(isNatListActive(V))
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U31Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(V) → U31Active(isNatListActive(V))
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

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

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = 2·x1 + x2   
POL(U41Active(x1, x2)) = 2·x1 + x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + x2   
POL(U51Active(x1, x2)) = x1 + x2   
POL(U52(x1)) = x1   
POL(U52Active(x1)) = x1   
POL(U61(x1, x2, x3)) = x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = x1 + x2 + x3   
POL(U62(x1, x2)) = x1 + x2   
POL(U62Active(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = x1   
POL(isNatIList(x1)) = x1   
POL(isNatIListActive(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 2   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U31Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(V) → U31Active(isNatListActive(V))
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U31Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(V) → U31Active(isNatListActive(V))
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

isNatIListActive(V) → U31Active(isNatListActive(V))
isNatIListActive(zeros) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = 2·x1   
POL(U11Active(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = 1 + x1 + 2·x2   
POL(U41Active(x1, x2)) = 1 + x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + 2·x2   
POL(U51Active(x1, x2)) = x1 + 2·x2   
POL(U52(x1)) = 2·x1   
POL(U52Active(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + 2·x2 + x3   
POL(U62(x1, x2)) = x1 + 2·x2   
POL(U62Active(x1, x2)) = x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = x1   
POL(isNatIList(x1)) = 1 + x1   
POL(isNatIListActive(x1)) = 1 + x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 2   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U31Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U31Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

U31Active(tt) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = 1 + x1   
POL(U31Active(x1)) = 1 + x1   
POL(U41(x1, x2)) = 2·x1 + 2·x2   
POL(U41Active(x1, x2)) = 2·x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + x2   
POL(U51Active(x1, x2)) = x1 + x2   
POL(U52(x1)) = x1   
POL(U52Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = x1 + 2·x2   
POL(U62Active(x1, x2)) = x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = 2·x1   
POL(isNatActive(x1)) = 2·x1   
POL(isNatIList(x1)) = 2·x1   
POL(isNatIListActive(x1)) = 2·x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt) → tt
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

U11Active(tt) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = 2 + x1   
POL(U11Active(x1)) = 2 + x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = 2·x1 + 2·x2   
POL(U41Active(x1, x2)) = 2·x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + 2·x2   
POL(U51Active(x1, x2)) = x1 + 2·x2   
POL(U52(x1)) = 2·x1   
POL(U52Active(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = 1 + x1 + 2·x2 + 2·x3   
POL(U61Active(x1, x2, x3)) = 1 + x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 1 + x1 + 2·x2   
POL(U62Active(x1, x2)) = 1 + x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = 2·x1   
POL(isNatActive(x1)) = 2·x1   
POL(isNatIList(x1)) = 2·x1   
POL(isNatIListActive(x1)) = 2·x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 1 + 2·x1   
POL(lengthActive(x1)) = 1 + 2·x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatListActive(V1))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

isNatActive(length(V1)) → U11Active(isNatListActive(V1))
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = x1 + 2·x2   
POL(U41Active(x1, x2)) = x1 + 2·x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = 2·x1 + 2·x2   
POL(U51Active(x1, x2)) = 2·x1 + 2·x2   
POL(U52(x1)) = 2·x1   
POL(U52Active(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = 2 + x1 + x2 + 2·x3   
POL(U61Active(x1, x2, x3)) = 2 + x1 + x2 + 2·x3   
POL(U62(x1, x2)) = 2 + 2·x1 + x2   
POL(U62Active(x1, x2)) = 2 + 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = x1   
POL(isNatIList(x1)) = 2·x1   
POL(isNatIListActive(x1)) = 2·x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2 + x1   
POL(lengthActive(x1)) = 2 + x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatActive(V1))
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

zerosActive → zeros
mark(isNat(x1)) → isNatActive(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
mark(isNatList(x1)) → isNatListActive(x1)
mark(0) → 0
mark(tt) → tt
mark(nil) → nil
isNatIListActive(cons(V1, V2)) → U41Active(isNatActive(V1), V2)
isNatListActive(cons(V1, V2)) → U51Active(isNatActive(V1), V2)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = x1 + x2   
POL(U41Active(x1, x2)) = x1 + x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + 2·x2   
POL(U51Active(x1, x2)) = x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U52Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 2 + x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = 2 + x1 + x2 + x3   
POL(U62(x1, x2)) = 2 + x1 + x2   
POL(U62Active(x1, x2)) = 2 + x1 + x2   
POL(cons(x1, x2)) = 2 + x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = x1   
POL(isNatIList(x1)) = x1   
POL(isNatIListActive(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = 2 + x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 2   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatIListActive(x1) → isNatIList(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatActive(V1))
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

Q is empty.

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatIListActive(x1) → isNatIList(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatActive(V1))
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

U41Active(tt, V2) → U42Active(isNatIListActive(V2))
U42Active(tt) → tt
U51Active(tt, V2) → U52Active(isNatListActive(V2))
isNatActive(s(V1)) → U21Active(isNatActive(V1))
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = x1 + 2·x2   
POL(U41Active(x1, x2)) = x1 + 2·x2   
POL(U42(x1)) = 2·x1   
POL(U42Active(x1)) = 2·x1   
POL(U51(x1, x2)) = x1 + x2   
POL(U51Active(x1, x2)) = x1 + x2   
POL(U52(x1)) = x1   
POL(U52Active(x1)) = x1   
POL(U61(x1, x2, x3)) = x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = x1 + x2 + x3   
POL(U62(x1, x2)) = x1 + x2   
POL(U62Active(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = 1 + x1   
POL(isNatActive(x1)) = 1 + x1   
POL(isNatIList(x1)) = x1   
POL(isNatIListActive(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = x1   
POL(s(x1)) = 1 + x1   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatIListActive(x1) → isNatIList(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

Q is empty.

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatIListActive(x1) → isNatIList(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U21Active(tt) → tt
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

isNatIListActive(x1) → isNatIList(x1)
U21Active(tt) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = 2 + x1   
POL(U21Active(x1)) = 2 + x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = 2·x1 + x2   
POL(U41Active(x1, x2)) = 2·x1 + x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + 2·x2   
POL(U51Active(x1, x2)) = x1 + 2·x2   
POL(U52(x1)) = x1   
POL(U52Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = 2·x1 + 2·x2   
POL(U62Active(x1, x2)) = 2·x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = x1   
POL(isNatIList(x1)) = x1   
POL(isNatIListActive(x1)) = 2 + x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

Q is empty.

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U52Active(tt) → tt
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

U52Active(tt) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = x1   
POL(U11Active(x1)) = x1   
POL(U21(x1)) = 2·x1   
POL(U21Active(x1)) = 2·x1   
POL(U31(x1)) = x1   
POL(U31Active(x1)) = x1   
POL(U41(x1, x2)) = x1 + x2   
POL(U41Active(x1, x2)) = x1 + x2   
POL(U42(x1)) = x1   
POL(U42Active(x1)) = x1   
POL(U51(x1, x2)) = x1 + x2   
POL(U51Active(x1, x2)) = x1 + x2   
POL(U52(x1)) = 1 + x1   
POL(U52Active(x1)) = 1 + x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + 2·x2 + x3   
POL(U62(x1, x2)) = x1 + 2·x2   
POL(U62Active(x1, x2)) = x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(s(x1)) = x1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

Q is empty.

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatActive(x1) → isNat(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

isNatActive(x1) → isNat(x1)
U62Active(tt, L) → s(lengthActive(mark(L)))
isNatActive(0) → tt
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = 2·x1   
POL(U11Active(x1)) = 2·x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = 2·x1   
POL(U31Active(x1)) = 2·x1   
POL(U41(x1, x2)) = x1 + x2   
POL(U41Active(x1, x2)) = x1 + x2   
POL(U42(x1)) = 2·x1   
POL(U42Active(x1)) = 2·x1   
POL(U51(x1, x2)) = x1 + x2   
POL(U51Active(x1, x2)) = x1 + x2   
POL(U52(x1)) = x1   
POL(U52Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62(x1, x2)) = x1 + 2·x2   
POL(U62Active(x1, x2)) = x1 + 2·x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNat(x1)) = 1 + x1   
POL(isNatActive(x1)) = 2 + x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = x1   
POL(s(x1)) = x1   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

Q is empty.

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
U11Active(x1) → U11(x1)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
U31Active(x1) → U31(x1)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U42(x1)) → U42Active(mark(x1))
U42Active(x1) → U42(x1)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
U51Active(x1, x2) → U51(x1, x2)
mark(U52(x1)) → U52Active(mark(x1))
U52Active(x1) → U52(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

U11Active(x1) → U11(x1)
U31Active(x1) → U31(x1)
U41Active(x1, x2) → U41(x1, x2)
U42Active(x1) → U42(x1)
U51Active(x1, x2) → U51(x1, x2)
U52Active(x1) → U52(x1)
U62Active(x1, x2) → U62(x1, x2)
mark(s(x1)) → s(mark(x1))
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = 1 + x1   
POL(U11Active(x1)) = 2 + x1   
POL(U21(x1)) = 2·x1   
POL(U21Active(x1)) = 2·x1   
POL(U31(x1)) = 1 + 2·x1   
POL(U31Active(x1)) = 2 + 2·x1   
POL(U41(x1, x2)) = 1 + x1 + x2   
POL(U41Active(x1, x2)) = 2 + x1 + 2·x2   
POL(U42(x1)) = 1 + x1   
POL(U42Active(x1)) = 2 + x1   
POL(U51(x1, x2)) = 1 + x1 + x2   
POL(U51Active(x1, x2)) = 2 + x1 + x2   
POL(U52(x1)) = 1 + x1   
POL(U52Active(x1)) = 2 + x1   
POL(U61(x1, x2, x3)) = 2·x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + x2 + 2·x3   
POL(U62(x1, x2)) = 1 + x1 + x2   
POL(U62Active(x1, x2)) = 2 + x1 + x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNatActive(x1)) = 2 + x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 2·x1   
POL(lengthActive(x1)) = 2·x1   
POL(mark(x1)) = 2·x1   
POL(s(x1)) = 1 + x1   
POL(tt) = 2   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof
                                                ↳ QTRS
                                                  ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
mark(U42(x1)) → U42Active(mark(x1))
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
mark(U52(x1)) → U52Active(mark(x1))
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

Q is empty.

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

mark(zeros) → zerosActive
mark(U11(x1)) → U11Active(mark(x1))
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1)) → U31Active(mark(x1))
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
mark(U42(x1)) → U42Active(mark(x1))
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
mark(U52(x1)) → U52Active(mark(x1))
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)

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

mark(U11(x1)) → U11Active(mark(x1))
mark(U31(x1)) → U31Active(mark(x1))
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
mark(U51(x1, x2)) → U51Active(mark(x1), x2)
mark(U52(x1)) → U52Active(mark(x1))
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(cons(N, L)) → U61Active(isNatListActive(L), L, N)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U11(x1)) = 2 + 2·x1   
POL(U11Active(x1)) = 2 + x1   
POL(U21(x1)) = x1   
POL(U21Active(x1)) = x1   
POL(U31(x1)) = 2 + x1   
POL(U31Active(x1)) = 2 + x1   
POL(U41(x1, x2)) = 2 + 2·x1 + x2   
POL(U41Active(x1, x2)) = 1 + x1 + 2·x2   
POL(U42(x1)) = 1 + 2·x1   
POL(U42Active(x1)) = 2 + 2·x1   
POL(U51(x1, x2)) = 2 + 2·x1 + x2   
POL(U51Active(x1, x2)) = 1 + 2·x1 + x2   
POL(U52(x1)) = 1 + 2·x1   
POL(U52Active(x1)) = 1 + 2·x1   
POL(U61(x1, x2, x3)) = x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = x1 + x2 + x3   
POL(U62(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(U62Active(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = 2·x1 + 2·x2   
POL(isNatActive(x1)) = 2 + x1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 1 + x1   
POL(lengthActive(x1)) = 1 + x1   
POL(mark(x1)) = 2·x1   
POL(tt) = 2   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof
                                                ↳ QTRS
                                                  ↳ RRRPoloQTRSProof
                                                    ↳ QTRS
                                                      ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U42(x1)) → U42Active(mark(x1))
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)

Q is empty.

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

mark(zeros) → zerosActive
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U42(x1)) → U42Active(mark(x1))
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)

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

U21Active(x1) → U21(x1)
lengthActive(x1) → length(x1)
U61Active(tt, L, N) → U62Active(isNatActive(N), L)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U21(x1)) = 1 + 2·x1   
POL(U21Active(x1)) = 2 + 2·x1   
POL(U42(x1)) = 2·x1   
POL(U42Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 2·x1 + 2·x2 + x3   
POL(U61Active(x1, x2, x3)) = 2·x1 + 2·x2 + 2·x3   
POL(U62Active(x1, x2)) = 1 + 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(isNatActive(x1)) = x1   
POL(isNatList(x1)) = 2 + x1   
POL(isNatListActive(x1)) = 2 + x1   
POL(length(x1)) = 1 + 2·x1   
POL(lengthActive(x1)) = 2 + 2·x1   
POL(mark(x1)) = 2·x1   
POL(tt) = 2   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof
                                                ↳ QTRS
                                                  ↳ RRRPoloQTRSProof
                                                    ↳ QTRS
                                                      ↳ RRRPoloQTRSProof
                                                        ↳ QTRS
                                                          ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U21(x1)) → U21Active(mark(x1))
mark(U42(x1)) → U42Active(mark(x1))
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)

Q is empty.

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

mark(zeros) → zerosActive
mark(U21(x1)) → U21Active(mark(x1))
mark(U42(x1)) → U42Active(mark(x1))
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)

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

mark(U21(x1)) → U21Active(mark(x1))
mark(U42(x1)) → U42Active(mark(x1))
mark(cons(x1, x2)) → cons(mark(x1), x2)
zerosActive → cons(0, zeros)
Used ordering:
Polynomial interpretation [25]:

POL(0) = 0   
POL(U21(x1)) = 1 + 2·x1   
POL(U21Active(x1)) = 1 + x1   
POL(U42(x1)) = 2 + 2·x1   
POL(U42Active(x1)) = 2 + x1   
POL(U61(x1, x2, x3)) = 2 + 2·x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = 2 + 2·x1 + 2·x2 + 2·x3   
POL(cons(x1, x2)) = 1 + x1 + x2   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(mark(x1)) = 2 + 2·x1   
POL(zeros) = 0   
POL(zerosActive) = 2   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof
                                                ↳ QTRS
                                                  ↳ RRRPoloQTRSProof
                                                    ↳ QTRS
                                                      ↳ RRRPoloQTRSProof
                                                        ↳ QTRS
                                                          ↳ RRRPoloQTRSProof
                                                            ↳ QTRS
                                                              ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)

Q is empty.

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

mark(zeros) → zerosActive
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)

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

U61Active(x1, x2, x3) → U61(x1, x2, x3)
isNatListActive(x1) → isNatList(x1)
Used ordering:
Polynomial interpretation [25]:

POL(U61(x1, x2, x3)) = 1 + x1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = 2 + x1 + 2·x2 + 2·x3   
POL(isNatList(x1)) = 1 + x1   
POL(isNatListActive(x1)) = 2 + 2·x1   
POL(mark(x1)) = 2·x1   
POL(zeros) = 0   
POL(zerosActive) = 0   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof
                                                ↳ QTRS
                                                  ↳ RRRPoloQTRSProof
                                                    ↳ QTRS
                                                      ↳ RRRPoloQTRSProof
                                                        ↳ QTRS
                                                          ↳ RRRPoloQTRSProof
                                                            ↳ QTRS
                                                              ↳ RRRPoloQTRSProof
                                                                ↳ QTRS
                                                                  ↳ RRRPoloQTRSProof

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

mark(zeros) → zerosActive
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)

Q is empty.

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

mark(zeros) → zerosActive
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)

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

mark(zeros) → zerosActive
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
Used ordering:
Polynomial interpretation [25]:

POL(U61(x1, x2, x3)) = 1 + 2·x1 + 2·x2 + 2·x3   
POL(U61Active(x1, x2, x3)) = 1 + x1 + x2 + x3   
POL(mark(x1)) = 2 + 2·x1   
POL(zeros) = 2   
POL(zerosActive) = 1   




↳ CSR
  ↳ Zantema-Transformation
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ RRRPoloQTRSProof
        ↳ QTRS
          ↳ RRRPoloQTRSProof
            ↳ QTRS
              ↳ RRRPoloQTRSProof
                ↳ QTRS
                  ↳ RRRPoloQTRSProof
                    ↳ QTRS
                      ↳ RRRPoloQTRSProof
                        ↳ QTRS
                          ↳ RRRPoloQTRSProof
                            ↳ QTRS
                              ↳ RRRPoloQTRSProof
                                ↳ QTRS
                                  ↳ RRRPoloQTRSProof
                                    ↳ QTRS
                                      ↳ RRRPoloQTRSProof
                                        ↳ QTRS
                                          ↳ RRRPoloQTRSProof
                                            ↳ QTRS
                                              ↳ RRRPoloQTRSProof
                                                ↳ QTRS
                                                  ↳ RRRPoloQTRSProof
                                                    ↳ QTRS
                                                      ↳ RRRPoloQTRSProof
                                                        ↳ QTRS
                                                          ↳ RRRPoloQTRSProof
                                                            ↳ QTRS
                                                              ↳ RRRPoloQTRSProof
                                                                ↳ QTRS
                                                                  ↳ RRRPoloQTRSProof
                                                                    ↳ QTRS
                                                                      ↳ RisEmptyProof

Q restricted rewrite system:
R is empty.
Q is empty.

The TRS R is empty. Hence, termination is trivially proven.