/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Problem 1: 

(VAR x y z)
(RULES
+(O(x),O(y)) -> O(+(x,y))
+(O(x),I(y)) -> I(+(x,y))
+(0,x) -> x
+(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
-(O(x),O(y)) -> O(-(x,y))
-(O(x),I(y)) -> I(-(-(x,y),I(1)))
-(0,x) -> 0
-(I(x),O(y)) -> I(-(x,y))
-(I(x),I(y)) -> O(-(x,y))
-(x,0) -> x
BS(L(x)) -> true
BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
Log(x) -> -(Log'(x),I(0))
Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
Log'(0) -> 0
Log'(I(x)) -> +(Log'(x),I(0))
Max(L(x)) -> x
Max(N(x,l,r)) -> Max(r)
Min(L(x)) -> x
Min(N(x,l,r)) -> Min(l)
O(0) -> 0
Size(L(x)) -> I(0)
Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
Val(L(x)) -> x
Val(N(x,l,r)) -> x
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)))
and(x,false) -> false
and(x,true) -> x
ge(O(x),O(y)) -> ge(x,y)
ge(O(x),I(y)) -> not(ge(y,x))
ge(0,O(x)) -> ge(0,x)
ge(0,I(x)) -> false
ge(I(x),O(y)) -> ge(x,y)
ge(I(x),I(y)) -> ge(x,y)
ge(x,0) -> true
if(false,x,y) -> y
if(true,x,y) -> x
not(false) -> true
not(true) -> false
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 +#(O(x),O(y)) -> +#(x,y)
 +#(O(x),O(y)) -> O#(+(x,y))
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(I(x),I(y)) -> O#(+(+(x,y),I(0)))
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
 -#(O(x),O(y)) -> -#(x,y)
 -#(O(x),O(y)) -> O#(-(x,y))
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
 -#(I(x),I(y)) -> O#(-(x,y))
 BS#(N(x,l,r)) -> AND(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 BS#(N(x,l,r)) -> AND(ge(x,Max(l)),ge(Min(r),x))
 BS#(N(x,l,r)) -> GE(Min(r),x)
 LOG(x) -> -#(Log'(x),I(0))
 LOG(x) -> LOG'(x)
 LOG'(O(x)) -> +#(Log'(x),I(0))
 LOG'(O(x)) -> LOG'(x)
 LOG'(O(x)) -> GE(x,I(0))
 LOG'(O(x)) -> IF(ge(x,I(0)),+(Log'(x),I(0)),0)
 LOG'(I(x)) -> +#(Log'(x),I(0))
 LOG'(I(x)) -> LOG'(x)
 GE(O(x),O(y)) -> GE(x,y)
 GE(O(x),I(y)) -> GE(y,x)
 GE(O(x),I(y)) -> NOT(ge(y,x))
 GE(0,O(x)) -> GE(0,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1: 

SCC Processor:
-> Pairs:
 +#(O(x),O(y)) -> +#(x,y)
 +#(O(x),O(y)) -> O#(+(x,y))
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(I(x),I(y)) -> O#(+(+(x,y),I(0)))
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
 -#(O(x),O(y)) -> -#(x,y)
 -#(O(x),O(y)) -> O#(-(x,y))
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
 -#(I(x),I(y)) -> O#(-(x,y))
 BS#(N(x,l,r)) -> AND(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 BS#(N(x,l,r)) -> AND(ge(x,Max(l)),ge(Min(r),x))
 BS#(N(x,l,r)) -> GE(Min(r),x)
 LOG(x) -> -#(Log'(x),I(0))
 LOG(x) -> LOG'(x)
 LOG'(O(x)) -> +#(Log'(x),I(0))
 LOG'(O(x)) -> LOG'(x)
 LOG'(O(x)) -> GE(x,I(0))
 LOG'(O(x)) -> IF(ge(x,I(0)),+(Log'(x),I(0)),0)
 LOG'(I(x)) -> +#(Log'(x),I(0))
 LOG'(I(x)) -> LOG'(x)
 GE(O(x),O(y)) -> GE(x,y)
 GE(O(x),I(y)) -> GE(y,x)
 GE(O(x),I(y)) -> NOT(ge(y,x))
 GE(0,O(x)) -> GE(0,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 GE(0,O(x)) -> GE(0,x)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->->Cycle:
->->-> Pairs:
 GE(O(x),O(y)) -> GE(x,y)
 GE(O(x),I(y)) -> GE(y,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->->Cycle:
->->-> Pairs:
 -#(O(x),O(y)) -> -#(x,y)
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->->Cycle:
->->-> Pairs:
 +#(O(x),O(y)) -> +#(x,y)
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->->Cycle:
->->-> Pairs:
 LOG'(O(x)) -> LOG'(x)
 LOG'(I(x)) -> LOG'(x)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false


The problem is decomposed in 5 subproblems.

Problem 1.1: 

Subterm Processor:
-> Pairs:
 GE(0,O(x)) -> GE(0,x)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Projection:
 pi(GE) = 2

Problem 1.1: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

Reduction Pair Processor:
-> Pairs:
 GE(O(x),O(y)) -> GE(x,y)
 GE(O(x),I(y)) -> GE(y,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 Empty
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[O](X) = 2.X + 1
[I](X) = 2.X
[GE](X1,X2) = 2.X1 + 2.X2

Problem 1.2: 

SCC Processor:
-> Pairs:
 GE(O(x),I(y)) -> GE(y,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 GE(O(x),I(y)) -> GE(y,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.2: 

Reduction Pair Processor:
-> Pairs:
 GE(O(x),I(y)) -> GE(y,x)
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 Empty
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[O](X) = 2.X + 2
[I](X) = 2.X
[GE](X1,X2) = 2.X1 + 2.X2

Problem 1.2: 

SCC Processor:
-> Pairs:
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.2: 

Subterm Processor:
-> Pairs:
 GE(I(x),O(y)) -> GE(x,y)
 GE(I(x),I(y)) -> GE(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Projection:
 pi(GE) = 1

Problem 1.2: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.3: 

Reduction Pair Processor:
-> Pairs:
 -#(O(x),O(y)) -> -#(x,y)
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 O(0) -> 0
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[-](X1,X2) = X1 + 2.X2
[O](X) = X + 2
[0] = 0
[1] = 0
[I](X) = X + 2
[-#](X1,X2) = X1 + 2.X2

Problem 1.3: 

SCC Processor:
-> Pairs:
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.3: 

Reduction Pair Processor:
-> Pairs:
 -#(O(x),I(y)) -> -#(-(x,y),I(1))
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 O(0) -> 0
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[-](X1,X2) = X1 + X2 + 1
[O](X) = X + 2
[0] = 1
[1] = 0
[I](X) = X + 1
[-#](X1,X2) = 2.X1 + 2.X2

Problem 1.3: 

SCC Processor:
-> Pairs:
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.3: 

Subterm Processor:
-> Pairs:
 -#(O(x),I(y)) -> -#(x,y)
 -#(I(x),O(y)) -> -#(x,y)
 -#(I(x),I(y)) -> -#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Projection:
 pi(-#) = 1

Problem 1.3: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.4: 

Reduction Pair Processor:
-> Pairs:
 +#(O(x),O(y)) -> +#(x,y)
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 O(0) -> 0
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[+](X1,X2) = X1 + X2 + 1
[O](X) = X + 1
[0] = 0
[I](X) = X + 2
[+#](X1,X2) = X1 + 2.X2

Problem 1.4: 

SCC Processor:
-> Pairs:
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.4: 

Reduction Pair Processor:
-> Pairs:
 +#(O(x),I(y)) -> +#(x,y)
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 O(0) -> 0
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[+](X1,X2) = X1 + X2
[O](X) = X
[0] = 2
[I](X) = X + 2
[+#](X1,X2) = 2.X1 + 2.X2

Problem 1.4: 

SCC Processor:
-> Pairs:
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.4: 

Reduction Pair Processor:
-> Pairs:
 +#(I(x),O(y)) -> +#(x,y)
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 O(0) -> 0
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[+](X1,X2) = X1 + 2.X2
[O](X) = X + 1
[0] = 0
[I](X) = X + 1
[+#](X1,X2) = X1 + 2.X2

Problem 1.4: 

SCC Processor:
-> Pairs:
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.4: 

Reduction Pair Processor:
-> Pairs:
 +#(I(x),I(y)) -> +#(+(x,y),I(0))
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
-> Usable rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 O(0) -> 0
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[+](X1,X2) = X1 + X2
[O](X) = 2.X
[0] = 0
[I](X) = 2.X + 2
[+#](X1,X2) = 2.X1 + 2.X2

Problem 1.4: 

SCC Processor:
-> Pairs:
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
->->-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false

Problem 1.4: 

Subterm Processor:
-> Pairs:
 +#(I(x),I(y)) -> +#(x,y)
 +#(x,+(y,z)) -> +#(+(x,y),z)
 +#(x,+(y,z)) -> +#(x,y)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Projection:
 pi(+#) = 2

Problem 1.4: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.5: 

Subterm Processor:
-> Pairs:
 LOG'(O(x)) -> LOG'(x)
 LOG'(I(x)) -> LOG'(x)
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Projection:
 pi(LOG') = 1

Problem 1.5: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 +(O(x),O(y)) -> O(+(x,y))
 +(O(x),I(y)) -> I(+(x,y))
 +(0,x) -> x
 +(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
 -(O(x),O(y)) -> O(-(x,y))
 -(O(x),I(y)) -> I(-(-(x,y),I(1)))
 -(0,x) -> 0
 -(I(x),O(y)) -> I(-(x,y))
 -(I(x),I(y)) -> O(-(x,y))
 -(x,0) -> x
 BS(L(x)) -> true
 BS(N(x,l,r)) -> and(and(ge(x,Max(l)),ge(Min(r),x)),and(BS(l),BS(r)))
 Log(x) -> -(Log'(x),I(0))
 Log'(O(x)) -> if(ge(x,I(0)),+(Log'(x),I(0)),0)
 Log'(0) -> 0
 Log'(I(x)) -> +(Log'(x),I(0))
 Max(L(x)) -> x
 Max(N(x,l,r)) -> Max(r)
 Min(L(x)) -> x
 Min(N(x,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x)) -> I(0)
 Size(N(x,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x)) -> x
 Val(N(x,l,r)) -> x
 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)))
 and(x,false) -> false
 and(x,true) -> x
 ge(O(x),O(y)) -> ge(x,y)
 ge(O(x),I(y)) -> not(ge(y,x))
 ge(0,O(x)) -> ge(0,x)
 ge(0,I(x)) -> false
 ge(I(x),O(y)) -> ge(x,y)
 ge(I(x),I(y)) -> ge(x,y)
 ge(x,0) -> true
 if(false,x,y) -> y
 if(true,x,y) -> x
 not(false) -> true
 not(true) -> false
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.