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:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.


QTRS
  ↳ DependencyPairsProof

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

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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:

-12(I1(x), I1(y)) -> O11(-2(x, y))
SIZE1(N3(x, l, r)) -> +12(Size1(l), Size1(r))
+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
BS11(N3(x, l, r)) -> AND2(ge2(x, Max1(l)), ge2(Min1(r), x))
BS11(N3(x, l, r)) -> MAX1(l)
WB11(N3(x, l, r)) -> GE2(Size1(l), Size1(r))
GE2(0, O1(x)) -> GE2(0, x)
SIZE1(N3(x, l, r)) -> SIZE1(l)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
WB11(N3(x, l, r)) -> AND2(WB1(l), WB1(r))
GE2(I1(x), I1(y)) -> GE2(x, y)
LOG'1(O1(x)) -> +12(Log'1(x), I1(0))
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
+12(x, +2(y, z)) -> +12(x, y)
WB11(N3(x, l, r)) -> SIZE1(l)
WB11(N3(x, l, r)) -> WB11(r)
-12(I1(x), I1(y)) -> -12(x, y)
LOG'1(O1(x)) -> LOG'1(x)
-12(I1(x), O1(y)) -> -12(x, y)
+12(I1(x), I1(y)) -> O11(+2(+2(x, y), I1(0)))
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
SIZE1(N3(x, l, r)) -> +12(+2(Size1(l), Size1(r)), I1(1))
WB11(N3(x, l, r)) -> AND2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))
BS11(N3(x, l, r)) -> BS11(l)
WB11(N3(x, l, r)) -> -12(Size1(r), Size1(l))
WB11(N3(x, l, r)) -> -12(Size1(l), Size1(r))
BS11(N3(x, l, r)) -> GE2(Min1(r), x)
SIZE1(N3(x, l, r)) -> SIZE1(r)
LOG'1(I1(x)) -> +12(Log'1(x), I1(0))
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
WB11(N3(x, l, r)) -> IF3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l))))
GE2(O1(x), I1(y)) -> NOT1(ge2(y, x))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(r), Size1(l)))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(l), Size1(r)))
LOG'1(O1(x)) -> GE2(x, I1(0))
LOG1(x) -> -12(Log'1(x), I1(0))
BS11(N3(x, l, r)) -> BS11(r)
LOG1(x) -> LOG'1(x)
BS11(N3(x, l, r)) -> AND2(BS1(l), BS1(r))
BS11(N3(x, l, r)) -> AND2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
+12(O1(x), O1(y)) -> O11(+2(x, y))
BS11(N3(x, l, r)) -> MIN1(r)
GE2(O1(x), O1(y)) -> GE2(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
WB11(N3(x, l, r)) -> WB11(l)
WB11(N3(x, l, r)) -> SIZE1(r)
BS11(N3(x, l, r)) -> GE2(x, Max1(l))
LOG'1(O1(x)) -> IF3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
-12(O1(x), O1(y)) -> O11(-2(x, y))
MAX1(N3(x, l, r)) -> MAX1(r)
LOG'1(I1(x)) -> LOG'1(x)
MIN1(N3(x, l, r)) -> MIN1(l)
+12(O1(x), O1(y)) -> +12(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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:

-12(I1(x), I1(y)) -> O11(-2(x, y))
SIZE1(N3(x, l, r)) -> +12(Size1(l), Size1(r))
+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
BS11(N3(x, l, r)) -> AND2(ge2(x, Max1(l)), ge2(Min1(r), x))
BS11(N3(x, l, r)) -> MAX1(l)
WB11(N3(x, l, r)) -> GE2(Size1(l), Size1(r))
GE2(0, O1(x)) -> GE2(0, x)
SIZE1(N3(x, l, r)) -> SIZE1(l)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
WB11(N3(x, l, r)) -> AND2(WB1(l), WB1(r))
GE2(I1(x), I1(y)) -> GE2(x, y)
LOG'1(O1(x)) -> +12(Log'1(x), I1(0))
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
+12(x, +2(y, z)) -> +12(x, y)
WB11(N3(x, l, r)) -> SIZE1(l)
WB11(N3(x, l, r)) -> WB11(r)
-12(I1(x), I1(y)) -> -12(x, y)
LOG'1(O1(x)) -> LOG'1(x)
-12(I1(x), O1(y)) -> -12(x, y)
+12(I1(x), I1(y)) -> O11(+2(+2(x, y), I1(0)))
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
SIZE1(N3(x, l, r)) -> +12(+2(Size1(l), Size1(r)), I1(1))
WB11(N3(x, l, r)) -> AND2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))
BS11(N3(x, l, r)) -> BS11(l)
WB11(N3(x, l, r)) -> -12(Size1(r), Size1(l))
WB11(N3(x, l, r)) -> -12(Size1(l), Size1(r))
BS11(N3(x, l, r)) -> GE2(Min1(r), x)
SIZE1(N3(x, l, r)) -> SIZE1(r)
LOG'1(I1(x)) -> +12(Log'1(x), I1(0))
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
WB11(N3(x, l, r)) -> IF3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l))))
GE2(O1(x), I1(y)) -> NOT1(ge2(y, x))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(r), Size1(l)))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(l), Size1(r)))
LOG'1(O1(x)) -> GE2(x, I1(0))
LOG1(x) -> -12(Log'1(x), I1(0))
BS11(N3(x, l, r)) -> BS11(r)
LOG1(x) -> LOG'1(x)
BS11(N3(x, l, r)) -> AND2(BS1(l), BS1(r))
BS11(N3(x, l, r)) -> AND2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
+12(O1(x), O1(y)) -> O11(+2(x, y))
BS11(N3(x, l, r)) -> MIN1(r)
GE2(O1(x), O1(y)) -> GE2(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
WB11(N3(x, l, r)) -> WB11(l)
WB11(N3(x, l, r)) -> SIZE1(r)
BS11(N3(x, l, r)) -> GE2(x, Max1(l))
LOG'1(O1(x)) -> IF3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
-12(O1(x), O1(y)) -> O11(-2(x, y))
MAX1(N3(x, l, r)) -> MAX1(r)
LOG'1(I1(x)) -> LOG'1(x)
MIN1(N3(x, l, r)) -> MIN1(l)
+12(O1(x), O1(y)) -> +12(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

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

GE2(0, O1(x)) -> GE2(0, x)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


GE2(0, O1(x)) -> GE2(0, x)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0) = 0   
POL(GE2(x1, x2)) = x2   
POL(O1(x1)) = 1 + x1   

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:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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:

GE2(I1(x), I1(y)) -> GE2(x, y)
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
GE2(O1(x), O1(y)) -> GE2(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


GE2(I1(x), I1(y)) -> GE2(x, y)
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
The remaining pairs can at least be oriented weakly.

GE2(O1(x), O1(y)) -> GE2(x, y)
Used ordering: Polynomial interpretation [21]:

POL(GE2(x1, x2)) = x1 + x2   
POL(I1(x1)) = 1 + x1   
POL(O1(x1)) = x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

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

GE2(O1(x), O1(y)) -> GE2(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


GE2(O1(x), O1(y)) -> GE2(x, y)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(GE2(x1, x2)) = x2   
POL(O1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

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

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

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

-12(I1(x), I1(y)) -> -12(x, y)
-12(I1(x), O1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


-12(I1(x), O1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
The remaining pairs can at least be oriented weakly.

-12(I1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
Used ordering: Polynomial interpretation [21]:

POL(-2(x1, x2)) = 0   
POL(-12(x1, x2)) = x2   
POL(0) = 0   
POL(1) = 0   
POL(I1(x1)) = x1   
POL(O1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

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

-12(I1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


-12(I1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
The remaining pairs can at least be oriented weakly.

-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
Used ordering: Polynomial interpretation [21]:

POL(-2(x1, x2)) = 0   
POL(-12(x1, x2)) = x2   
POL(0) = 0   
POL(1) = 0   
POL(I1(x1)) = 1 + x1   
POL(O1(x1)) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

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

-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(-2(x1, x2)) = x1   
POL(-12(x1, x2)) = x1   
POL(0) = 0   
POL(1) = 0   
POL(I1(x1)) = 1 + x1   
POL(O1(x1)) = 1 + x1   

The following usable rules [14] were oriented:

-2(I1(x), O1(y)) -> I1(-2(x, y))
O1(0) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(x, 0) -> x
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(0, x) -> 0
-2(I1(x), I1(y)) -> O1(-2(x, y))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ QDPOrderProof
QDP
                        ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP

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

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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:

+12(I1(x), O1(y)) -> +12(x, y)
+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(x, +2(y, z)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
+12(O1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


+12(I1(x), O1(y)) -> +12(x, y)
+12(O1(x), O1(y)) -> +12(x, y)
The remaining pairs can at least be oriented weakly.

+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(x, +2(y, z)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
Used ordering: Polynomial interpretation [21]:

POL(+2(x1, x2)) = x1 + x2   
POL(+12(x1, x2)) = x2   
POL(0) = 0   
POL(I1(x1)) = x1   
POL(O1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP

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

+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(I1(x), I1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


+12(x, +2(y, z)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
The remaining pairs can at least be oriented weakly.

+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(I1(x), I1(y)) -> +12(x, y)
Used ordering: Polynomial interpretation [21]:

POL(+2(x1, x2)) = 1 + x1 + x2   
POL(+12(x1, x2)) = x2   
POL(0) = 0   
POL(I1(x1)) = x1   
POL(O1(x1)) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ QDPOrderProof
          ↳ QDP

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

+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(I1(x), I1(y)) -> +12(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
The remaining pairs can at least be oriented weakly.

+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
Used ordering: Polynomial interpretation [21]:

POL(+2(x1, x2)) = 0   
POL(+12(x1, x2)) = x2   
POL(0) = 0   
POL(I1(x1)) = 1 + x1   
POL(O1(x1)) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ QDPOrderProof
QDP
                        ↳ QDPOrderProof
          ↳ QDP

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

+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(+2(x1, x2)) = x1 + x2   
POL(+12(x1, x2)) = x1 + x2   
POL(0) = 0   
POL(I1(x1)) = 1 + x1   
POL(O1(x1)) = x1   

The following usable rules [14] were oriented:

O1(0) -> 0
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, 0) -> x
+2(0, x) -> x
+2(x, +2(y, z)) -> +2(+2(x, y), z)
+2(O1(x), O1(y)) -> O1(+2(x, y))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ QDPOrderProof
                      ↳ QDP
                        ↳ QDPOrderProof
QDP
                            ↳ PisEmptyProof
          ↳ QDP

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

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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
QDP
            ↳ QDPOrderProof

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

LOG'1(O1(x)) -> LOG'1(x)
LOG'1(I1(x)) -> LOG'1(x)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


LOG'1(O1(x)) -> LOG'1(x)
The remaining pairs can at least be oriented weakly.

LOG'1(I1(x)) -> LOG'1(x)
Used ordering: Polynomial interpretation [21]:

POL(I1(x1)) = x1   
POL(LOG'1(x1)) = x1   
POL(O1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof

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

LOG'1(I1(x)) -> LOG'1(x)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.


LOG'1(I1(x)) -> LOG'1(x)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(I1(x1)) = 1 + x1   
POL(LOG'1(x1)) = x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ PisEmptyProof

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

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

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.