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

0 QTRS
↳1 DependencyPairsProof (⇔)
↳2 QDP
↳3 DependencyGraphProof (⇔)
↳4 AND
  ↳5 QDP
    ↳6 QDPOrderProof (⇔)
    ↳7 QDP
    ↳8 PisEmptyProof (⇔)
    ↳9 TRUE
  ↳10 QDP
    ↳11 QDPOrderProof (⇔)
    ↳12 QDP
    ↳13 QDPOrderProof (⇔)
    ↳14 QDP
    ↳15 QDPOrderProof (⇔)
    ↳16 QDP
    ↳17 PisEmptyProof (⇔)
    ↳18 TRUE

(0) Obligation:

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

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.

(2) Obligation:

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

A__EQ(s(X), s(Y)) → A__EQ(X, Y)
MARK(eq(X1, X2)) → A__EQ(X1, X2)
MARK(inf(X)) → A__INF(mark(X))
MARK(inf(X)) → MARK(X)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(take(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(length(X)) → A__LENGTH(mark(X))
MARK(length(X)) → MARK(X)

The TRS R consists of the following rules:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(3) DependencyGraphProof (EQUIVALENT transformation)

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

(4) Complex Obligation (AND)

(5) Obligation:

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

A__EQ(s(X), s(Y)) → A__EQ(X, Y)

The TRS R consists of the following rules:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(6) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


A__EQ(s(X), s(Y)) → A__EQ(X, Y)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
A__EQ(x1, x2)  =  x1
s(x1)  =  s(x1)
a__eq(x1, x2)  =  a__eq(x1)
0  =  0
true  =  true
false  =  false
a__inf(x1)  =  x1
cons(x1, x2)  =  x1
inf(x1)  =  x1
a__take(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
a__length(x1)  =  a__length
length(x1)  =  length
mark(x1)  =  mark(x1)
eq(x1, x2)  =  eq(x1)

Recursive Path Order [RPO].
Precedence:
mark1 > alength > [s1, aeq1] > true > [nil, eq1]
mark1 > alength > [s1, aeq1] > false > [nil, eq1]
mark1 > alength > 0 > true > [nil, eq1]
mark1 > alength > length > [nil, eq1]


The following usable rules [FROCOS05] were oriented:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

(7) Obligation:

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

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(8) PisEmptyProof (EQUIVALENT transformation)

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

(9) TRUE

(10) Obligation:

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

MARK(take(X1, X2)) → MARK(X1)
MARK(inf(X)) → MARK(X)
MARK(take(X1, X2)) → MARK(X2)
MARK(length(X)) → MARK(X)

The TRS R consists of the following rules:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(11) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(take(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  x1
take(x1, x2)  =  take(x1, x2)
inf(x1)  =  x1
length(x1)  =  x1
a__eq(x1, x2)  =  a__eq(x1, x2)
0  =  0
true  =  true
s(x1)  =  x1
false  =  false
a__inf(x1)  =  x1
cons(x1, x2)  =  x2
a__take(x1, x2)  =  a__take(x1, x2)
nil  =  nil
a__length(x1)  =  x1
mark(x1)  =  mark(x1)
eq(x1, x2)  =  eq(x1, x2)

Recursive Path Order [RPO].
Precedence:
mark1 > [aeq2, false, eq2] > true
mark1 > [atake2, nil] > take2
mark1 > [atake2, nil] > 0


The following usable rules [FROCOS05] were oriented:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

(12) Obligation:

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

MARK(inf(X)) → MARK(X)
MARK(length(X)) → MARK(X)

The TRS R consists of the following rules:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(13) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(inf(X)) → MARK(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  MARK(x1)
inf(x1)  =  inf(x1)
length(x1)  =  x1
a__eq(x1, x2)  =  x1
0  =  0
true  =  true
s(x1)  =  x1
false  =  false
a__inf(x1)  =  a__inf(x1)
cons(x1, x2)  =  cons(x1, x2)
a__take(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
a__length(x1)  =  x1
mark(x1)  =  mark(x1)
eq(x1, x2)  =  x1

Recursive Path Order [RPO].
Precedence:
mark1 > ainf1 > [MARK1, inf1, 0, true, false, cons2, nil]


The following usable rules [FROCOS05] were oriented:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

(14) Obligation:

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

MARK(length(X)) → MARK(X)

The TRS R consists of the following rules:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(15) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


MARK(length(X)) → MARK(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
MARK(x1)  =  x1
length(x1)  =  length(x1)
a__eq(x1, x2)  =  a__eq(x1, x2)
0  =  0
true  =  true
s(x1)  =  x1
false  =  false
a__inf(x1)  =  a__inf
cons(x1, x2)  =  x2
inf(x1)  =  inf
a__take(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
a__length(x1)  =  a__length(x1)
mark(x1)  =  mark(x1)
eq(x1, x2)  =  eq(x1, x2)

Recursive Path Order [RPO].
Precedence:
mark1 > [aeq2, eq2] > true > nil
mark1 > [aeq2, eq2] > false > nil
mark1 > [ainf, inf] > nil
mark1 > alength1 > length1 > nil
mark1 > alength1 > 0 > nil


The following usable rules [FROCOS05] were oriented:

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

(16) Obligation:

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

a__eq(0, 0) → true
a__eq(s(X), s(Y)) → a__eq(X, Y)
a__eq(X, Y) → false
a__inf(X) → cons(X, inf(s(X)))
a__take(0, X) → nil
a__take(s(X), cons(Y, L)) → cons(Y, take(X, L))
a__length(nil) → 0
a__length(cons(X, L)) → s(length(L))
mark(eq(X1, X2)) → a__eq(X1, X2)
mark(inf(X)) → a__inf(mark(X))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(length(X)) → a__length(mark(X))
mark(0) → 0
mark(true) → true
mark(s(X)) → s(X)
mark(false) → false
mark(cons(X1, X2)) → cons(X1, X2)
mark(nil) → nil
a__eq(X1, X2) → eq(X1, X2)
a__inf(X) → inf(X)
a__take(X1, X2) → take(X1, X2)
a__length(X) → length(X)

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

(17) PisEmptyProof (EQUIVALENT transformation)

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

(18) TRUE