Termination w.r.t. Q proof of TRS/nontermin/AG01#4.36.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

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

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

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

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.

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

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))
EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)
SORT₁(cons₂(n, x)) -> REPLACE₃(min₁(cons₂(n, x)), n, x)
MIN₁(cons₂(n, cons₂(m, x))) -> LE₂(n, m)
LE₂(s₁(n), s₁(m)) -> LE₂(n, m)
SORT₁(cons₂(n, x)) -> MIN₁(cons₂(n, x))
REPLACE₃(n, m, cons₂(k, x)) -> EQ₂(n, k)
SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))
IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))
IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

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

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

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

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))
EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)
SORT₁(cons₂(n, x)) -> REPLACE₃(min₁(cons₂(n, x)), n, x)
MIN₁(cons₂(n, cons₂(m, x))) -> LE₂(n, m)
LE₂(s₁(n), s₁(m)) -> LE₂(n, m)
SORT₁(cons₂(n, x)) -> MIN₁(cons₂(n, x))
REPLACE₃(n, m, cons₂(k, x)) -> EQ₂(n, k)
SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))
IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))
IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 5 SCCs with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

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

LE₂(s₁(n), s₁(m)) -> LE₂(n, m)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LE₂(s₁(n), s₁(m)) -> LE₂(n, m)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(LE₂(x₁, x₂)) = x₂
POL(s₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

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

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

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.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

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

IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))

The remaining pairs can at least be oriented weakly.

MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))

Used ordering: Polynomial interpretation [21]:

POL(0) = 0
POL(IF_MIN₂(x₁, x₂)) = x₂
POL(MIN₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = 1 + x₂
POL(false) = 0
POL(le₂(x₁, x₂)) = 0
POL(s₁(x₁)) = 0
POL(true) = 0

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

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

MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

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

EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(EQ₂(x₁, x₂)) = x₂
POL(s₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

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

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

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.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

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

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))
IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The remaining pairs can at least be oriented weakly.

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))

Used ordering: Polynomial interpretation [21]:

POL(0) = 0
POL(IF_REPLACE₄(x₁, x₂, x₃, x₄)) = x₄
POL(REPLACE₃(x₁, x₂, x₃)) = x₃
POL(cons₂(x₁, x₂)) = 1 + x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 0
POL(s₁(x₁)) = 0
POL(true) = 0

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

          ↳ QDP

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

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

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

SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0) = 0
POL(SORT₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = 1 + x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 0
POL(if_min₂(x₁, x₂)) = 0
POL(if_replace₄(x₁, x₂, x₃, x₄)) = x₄
POL(le₂(x₁, x₂)) = 0
POL(min₁(x₁)) = 0
POL(nil) = 0
POL(replace₃(x₁, x₂, x₃)) = x₃
POL(s₁(x₁)) = 0
POL(true) = 0

The following usable rules [14] were oriented:

replace₃(n, m, nil) -> nil
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

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

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

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.