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

0 QTRS
↳1 QTRSRRRProof (⇔)
↳2 QTRS
↳3 QTRSRRRProof (⇔)
↳4 QTRS
↳5 QTRSRRRProof (⇔)
↳6 QTRS
↳7 QTRSRRRProof (⇔)
↳8 QTRS
↳9 DependencyPairsProof (⇔)
↳10 QDP
↳11 DependencyGraphProof (⇔)
↳12 AND
  ↳13 QDP
    ↳14 UsableRulesProof (⇔)
    ↳15 QDP
    ↳16 QDPSizeChangeProof (⇔)
    ↳17 TRUE
  ↳18 QDP
    ↳19 UsableRulesProof (⇔)
    ↳20 QDP
    ↳21 QDPSizeChangeProof (⇔)
    ↳22 TRUE
  ↳23 QDP
    ↳24 UsableRulesProof (⇔)
    ↳25 QDP
    ↳26 MRRProof (⇔)
    ↳27 QDP
    ↳28 PisEmptyProof (⇔)
    ↳29 TRUE
  ↳30 QDP
    ↳31 UsableRulesProof (⇔)
    ↳32 QDP
    ↳33 MRRProof (⇔)
    ↳34 QDP
    ↳35 QDPSizeChangeProof (⇔)
    ↳36 TRUE
  ↳37 QDP
    ↳38 UsableRulesProof (⇔)
    ↳39 QDP
    ↳40 QDPSizeChangeProof (⇔)
    ↳41 TRUE

(0) Obligation:

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

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
and(x, true) → x
and(x, false) → false
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(0) → 0
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)
Log(x) → -(Log'(x), I(0))
Val(L(x)) → x
Val(N(x, l, r)) → x
Min(L(x)) → x
Min(N(x, l, r)) → Min(l)
Max(L(x)) → x
Max(N(x, l, r)) → Max(r)
BS(L(x)) → true
BS(N(x, l, r)) → and(and(ge(x, Max(l)), ge(Min(r), x)), and(BS(l), BS(r)))
Size(L(x)) → I(0)
Size(N(x, l, r)) → +(+(Size(l), Size(r)), I(1))
WB(L(x)) → true
WB(N(x, l, r)) → and(if(ge(Size(l), Size(r)), ge(I(0), -(Size(l), Size(r))), ge(I(0), -(Size(r), Size(l)))), and(WB(l), WB(r)))

Q is empty.

(1) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(+(x1, x2)) = x1 + x2   
POL(-(x1, x2)) = x1 + x2   
POL(0) = 0   
POL(1) = 0   
POL(BS(x1)) = 2·x1   
POL(I(x1)) = 2·x1   
POL(L(x1)) = 2 + x1   
POL(Log(x1)) = 1 + x1   
POL(Log'(x1)) = x1   
POL(Max(x1)) = x1   
POL(Min(x1)) = 2·x1   
POL(N(x1, x2, x3)) = 2·x1 + x2 + x3   
POL(O(x1)) = 2·x1   
POL(Size(x1)) = 2·x1   
POL(Val(x1)) = 2 + 2·x1   
POL(WB(x1)) = 2·x1   
POL(and(x1, x2)) = x1 + 2·x2   
POL(false) = 0   
POL(ge(x1, x2)) = x1 + x2   
POL(if(x1, x2, x3)) = x1 + x2 + 2·x3   
POL(l) = 0   
POL(not(x1)) = x1   
POL(r) = 0   
POL(true) = 0   
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

Log(x) → -(Log'(x), I(0))
Val(L(x)) → x
Val(N(x, l, r)) → x
Min(L(x)) → x
Max(L(x)) → x
BS(L(x)) → true
Size(L(x)) → I(0)
WB(L(x)) → true


(2) Obligation:

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

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
and(x, true) → x
and(x, false) → false
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(0) → 0
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)
Min(N(x, l, r)) → Min(l)
Max(N(x, l, r)) → Max(r)
BS(N(x, l, r)) → and(and(ge(x, Max(l)), ge(Min(r), x)), and(BS(l), BS(r)))
Size(N(x, l, r)) → +(+(Size(l), Size(r)), I(1))
WB(N(x, l, r)) → and(if(ge(Size(l), Size(r)), ge(I(0), -(Size(l), Size(r))), ge(I(0), -(Size(r), Size(l)))), and(WB(l), WB(r)))

Q is empty.

(3) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(+(x1, x2)) = x1 + x2   
POL(-(x1, x2)) = x1 + 2·x2   
POL(0) = 0   
POL(1) = 0   
POL(BS(x1)) = 2·x1   
POL(I(x1)) = 2·x1   
POL(Log'(x1)) = x1   
POL(Max(x1)) = 2·x1   
POL(Min(x1)) = 1 + x1   
POL(N(x1, x2, x3)) = 1 + 2·x1 + 2·x2 + x3   
POL(O(x1)) = 2·x1   
POL(Size(x1)) = 2·x1   
POL(WB(x1)) = x1   
POL(and(x1, x2)) = x1 + x2   
POL(false) = 0   
POL(ge(x1, x2)) = x1 + 2·x2   
POL(if(x1, x2, x3)) = x1 + x2 + 2·x3   
POL(l) = 0   
POL(not(x1)) = x1   
POL(r) = 0   
POL(true) = 0   
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

Min(N(x, l, r)) → Min(l)
Max(N(x, l, r)) → Max(r)
BS(N(x, l, r)) → and(and(ge(x, Max(l)), ge(Min(r), x)), and(BS(l), BS(r)))
Size(N(x, l, r)) → +(+(Size(l), Size(r)), I(1))
WB(N(x, l, r)) → and(if(ge(Size(l), Size(r)), ge(I(0), -(Size(l), Size(r))), ge(I(0), -(Size(r), Size(l)))), and(WB(l), WB(r)))


(4) Obligation:

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

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
and(x, true) → x
and(x, false) → false
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(0) → 0
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

Q is empty.

(5) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(+(x1, x2)) = x1 + 2·x2   
POL(-(x1, x2)) = x1 + 2·x2   
POL(0) = 0   
POL(1) = 0   
POL(I(x1)) = 2·x1   
POL(Log'(x1)) = 2·x1   
POL(O(x1)) = 2·x1   
POL(and(x1, x2)) = 1 + x1 + 2·x2   
POL(false) = 0   
POL(ge(x1, x2)) = 2·x1 + 2·x2   
POL(if(x1, x2, x3)) = x1 + x2 + x3   
POL(not(x1)) = 2·x1   
POL(true) = 0   
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

and(x, true) → x
and(x, false) → false


(6) Obligation:

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

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(0) → 0
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

Q is empty.

(7) QTRSRRRProof (EQUIVALENT transformation)

Used ordering:
Polynomial interpretation [POLO]:

POL(+(x1, x2)) = x1 + x2   
POL(-(x1, x2)) = x1 + 2·x2   
POL(0) = 0   
POL(1) = 0   
POL(I(x1)) = 2·x1   
POL(Log'(x1)) = 2 + 2·x1   
POL(O(x1)) = 2·x1   
POL(false) = 0   
POL(ge(x1, x2)) = x1 + x2   
POL(if(x1, x2, x3)) = x1 + x2 + 2·x3   
POL(not(x1)) = x1   
POL(true) = 0   
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

Log'(0) → 0


(8) Obligation:

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

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

Q is empty.

(9) DependencyPairsProof (EQUIVALENT transformation)

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

(10) Obligation:

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

+1(O(x), O(y)) → O1(+(x, y))
+1(O(x), O(y)) → +1(x, y)
+1(O(x), I(y)) → +1(x, y)
+1(I(x), O(y)) → +1(x, y)
+1(I(x), I(y)) → O1(+(+(x, y), I(0)))
+1(I(x), I(y)) → +1(+(x, y), I(0))
+1(I(x), I(y)) → +1(x, y)
+1(x, +(y, z)) → +1(+(x, y), z)
+1(x, +(y, z)) → +1(x, y)
-1(O(x), O(y)) → O1(-(x, y))
-1(O(x), O(y)) → -1(x, y)
-1(O(x), I(y)) → -1(-(x, y), I(1))
-1(O(x), I(y)) → -1(x, y)
-1(I(x), O(y)) → -1(x, y)
-1(I(x), I(y)) → O1(-(x, y))
-1(I(x), I(y)) → -1(x, y)
GE(O(x), O(y)) → GE(x, y)
GE(O(x), I(y)) → NOT(ge(y, x))
GE(O(x), I(y)) → GE(y, x)
GE(I(x), O(y)) → GE(x, y)
GE(I(x), I(y)) → GE(x, y)
GE(0, O(x)) → GE(0, x)
LOG'(I(x)) → +1(Log'(x), I(0))
LOG'(I(x)) → LOG'(x)
LOG'(O(x)) → IF(ge(x, I(0)), +(Log'(x), I(0)), 0)
LOG'(O(x)) → GE(x, I(0))
LOG'(O(x)) → +1(Log'(x), I(0))
LOG'(O(x)) → LOG'(x)

The TRS R consists of the following rules:

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

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

(11) DependencyGraphProof (EQUIVALENT transformation)

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

(12) Complex Obligation (AND)

(13) Obligation:

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

GE(0, O(x)) → GE(0, x)

The TRS R consists of the following rules:

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

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

(14) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(15) Obligation:

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

GE(0, O(x)) → GE(0, x)

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

(16) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • GE(0, O(x)) → GE(0, x)
    The graph contains the following edges 1 >= 1, 2 > 2

(17) TRUE

(18) Obligation:

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

GE(O(x), I(y)) → GE(y, x)
GE(O(x), O(y)) → GE(x, y)
GE(I(x), O(y)) → GE(x, y)
GE(I(x), I(y)) → GE(x, y)

The TRS R consists of the following rules:

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

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

(19) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(20) Obligation:

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

GE(O(x), I(y)) → GE(y, x)
GE(O(x), O(y)) → GE(x, y)
GE(I(x), O(y)) → GE(x, y)
GE(I(x), I(y)) → GE(x, y)

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

(21) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • GE(O(x), I(y)) → GE(y, x)
    The graph contains the following edges 2 > 1, 1 > 2

  • GE(O(x), O(y)) → GE(x, y)
    The graph contains the following edges 1 > 1, 2 > 2

  • GE(I(x), O(y)) → GE(x, y)
    The graph contains the following edges 1 > 1, 2 > 2

  • GE(I(x), I(y)) → GE(x, y)
    The graph contains the following edges 1 > 1, 2 > 2

(22) TRUE

(23) Obligation:

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

-1(O(x), I(y)) → -1(-(x, y), I(1))
-1(O(x), I(y)) → -1(x, y)
-1(O(x), O(y)) → -1(x, y)
-1(I(x), O(y)) → -1(x, y)
-1(I(x), I(y)) → -1(x, y)

The TRS R consists of the following rules:

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

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

(24) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(25) Obligation:

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

-1(O(x), I(y)) → -1(-(x, y), I(1))
-1(O(x), I(y)) → -1(x, y)
-1(O(x), O(y)) → -1(x, y)
-1(I(x), O(y)) → -1(x, y)
-1(I(x), I(y)) → -1(x, y)

The TRS R consists of the following rules:

-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
O(0) → 0

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

(26) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

-1(O(x), I(y)) → -1(-(x, y), I(1))
-1(O(x), I(y)) → -1(x, y)
-1(O(x), O(y)) → -1(x, y)
-1(I(x), O(y)) → -1(x, y)
-1(I(x), I(y)) → -1(x, y)

Strictly oriented rules of the TRS R:

-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
O(0) → 0

Used ordering: Polynomial interpretation [POLO]:

POL(-(x1, x2)) = 1 + x1 + x2   
POL(-1(x1, x2)) = x1 + x2   
POL(0) = 0   
POL(1) = 0   
POL(I(x1)) = 3 + x1   
POL(O(x1)) = 5 + x1   

(27) Obligation:

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

(28) PisEmptyProof (EQUIVALENT transformation)

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

(29) TRUE

(30) Obligation:

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

+1(O(x), I(y)) → +1(x, y)
+1(O(x), O(y)) → +1(x, y)
+1(I(x), O(y)) → +1(x, y)
+1(I(x), I(y)) → +1(+(x, y), I(0))
+1(I(x), I(y)) → +1(x, y)
+1(x, +(y, z)) → +1(+(x, y), z)
+1(x, +(y, z)) → +1(x, y)

The TRS R consists of the following rules:

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

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

(31) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(32) Obligation:

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

+1(O(x), I(y)) → +1(x, y)
+1(O(x), O(y)) → +1(x, y)
+1(I(x), O(y)) → +1(x, y)
+1(I(x), I(y)) → +1(+(x, y), I(0))
+1(I(x), I(y)) → +1(x, y)
+1(x, +(y, z)) → +1(+(x, y), z)
+1(x, +(y, z)) → +1(x, y)

The TRS R consists of the following rules:

+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
O(0) → 0

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

(33) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

+1(O(x), I(y)) → +1(x, y)
+1(I(x), O(y)) → +1(x, y)
+1(I(x), I(y)) → +1(+(x, y), I(0))
+1(I(x), I(y)) → +1(x, y)
+1(x, +(y, z)) → +1(x, y)

Strictly oriented rules of the TRS R:

+(0, x) → x
+(x, 0) → x
+(I(x), I(y)) → O(+(+(x, y), I(0)))

Used ordering: Polynomial interpretation [POLO]:

POL(+(x1, x2)) = 1 + x1 + x2   
POL(+1(x1, x2)) = x1 + x2   
POL(0) = 0   
POL(I(x1)) = 2 + x1   
POL(O(x1)) = x1   

(34) Obligation:

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

+1(O(x), O(y)) → +1(x, y)
+1(x, +(y, z)) → +1(+(x, y), z)

The TRS R consists of the following rules:

+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(x, +(y, z)) → +(+(x, y), z)
O(0) → 0

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

(35) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • +1(O(x), O(y)) → +1(x, y)
    The graph contains the following edges 1 > 1, 2 > 2

  • +1(x, +(y, z)) → +1(+(x, y), z)
    The graph contains the following edges 2 > 2

(36) TRUE

(37) Obligation:

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

LOG'(O(x)) → LOG'(x)
LOG'(I(x)) → LOG'(x)

The TRS R consists of the following rules:

O(0) → 0
+(0, x) → x
+(x, 0) → x
+(O(x), O(y)) → O(+(x, y))
+(O(x), I(y)) → I(+(x, y))
+(I(x), O(y)) → I(+(x, y))
+(I(x), I(y)) → O(+(+(x, y), I(0)))
+(x, +(y, z)) → +(+(x, y), z)
-(x, 0) → x
-(0, x) → 0
-(O(x), O(y)) → O(-(x, y))
-(O(x), I(y)) → I(-(-(x, y), I(1)))
-(I(x), O(y)) → I(-(x, y))
-(I(x), I(y)) → O(-(x, y))
not(true) → false
not(false) → true
if(true, x, y) → x
if(false, x, y) → y
ge(O(x), O(y)) → ge(x, y)
ge(O(x), I(y)) → not(ge(y, x))
ge(I(x), O(y)) → ge(x, y)
ge(I(x), I(y)) → ge(x, y)
ge(x, 0) → true
ge(0, O(x)) → ge(0, x)
ge(0, I(x)) → false
Log'(I(x)) → +(Log'(x), I(0))
Log'(O(x)) → if(ge(x, I(0)), +(Log'(x), I(0)), 0)

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

(38) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(39) Obligation:

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

LOG'(O(x)) → LOG'(x)
LOG'(I(x)) → LOG'(x)

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

(40) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

  • LOG'(O(x)) → LOG'(x)
    The graph contains the following edges 1 > 1

  • LOG'(I(x)) → LOG'(x)
    The graph contains the following edges 1 > 1

(41) TRUE