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


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


YES

Problem 1: 

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

Problem 1: 

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

Problem 1: 

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


The problem is decomposed in 5 subproblems.

Problem 1.1: 

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

Problem 1.1: 

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

The problem is finite.

Problem 1.2: 

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

Problem 1.2: 

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

Problem 1.2: 

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

Problem 1.2: 

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

Problem 1.2: 

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

The problem is finite.

Problem 1.3: 

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

Problem 1.3: 

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

Problem 1.3: 

Reduction Pair Processor:
-> Pairs:
 -#(O(x:S),I(y:S)) -> -#(-(x:S,y:S),I(1))
 -#(O(x:S),I(y:S)) -> -#(x:S,y:S)
 -#(I(x:S),O(y:S)) -> -#(x:S,y:S)
 -#(I(x:S),I(y:S)) -> -#(x:S,y:S)
-> Rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 -(O(x:S),O(y:S)) -> O(-(x:S,y:S))
 -(O(x:S),I(y:S)) -> I(-(-(x:S,y:S),I(1)))
 -(0,x:S) -> 0
 -(I(x:S),O(y:S)) -> I(-(x:S,y:S))
 -(I(x:S),I(y:S)) -> O(-(x:S,y:S))
 -(x:S,0) -> x:S
 BS(L(x:S)) -> ttrue
 BS(N(x:S,l,r)) -> and(and(ge(x:S,Max(l)),ge(Min(r),x:S)),and(BS(l),BS(r)))
 Log(x:S) -> -(Log'(x:S),I(0))
 Log'(O(x:S)) -> if(ge(x:S,I(0)),+(Log'(x:S),I(0)),0)
 Log'(0) -> 0
 Log'(I(x:S)) -> +(Log'(x:S),I(0))
 Max(L(x:S)) -> x:S
 Max(N(x:S,l,r)) -> Max(r)
 Min(L(x:S)) -> x:S
 Min(N(x:S,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x:S)) -> I(0)
 Size(N(x:S,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x:S)) -> x:S
 Val(N(x:S,l,r)) -> x:S
 WB(L(x:S)) -> ttrue
 WB(N(x:S,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:S,ffalse) -> ffalse
 and(x:S,ttrue) -> x:S
 ge(O(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(O(x:S),I(y:S)) -> not(ge(y:S,x:S))
 ge(0,O(x:S)) -> ge(0,x:S)
 ge(0,I(x:S)) -> ffalse
 ge(I(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(I(x:S),I(y:S)) -> ge(x:S,y:S)
 ge(x:S,0) -> ttrue
 if(ffalse,x:S,y:S) -> y:S
 if(ttrue,x:S,y:S) -> x:S
 not(ffalse) -> ttrue
 not(ttrue) -> ffalse
-> Usable rules:
 -(O(x:S),O(y:S)) -> O(-(x:S,y:S))
 -(O(x:S),I(y:S)) -> I(-(-(x:S,y:S),I(1)))
 -(0,x:S) -> 0
 -(I(x:S),O(y:S)) -> I(-(x:S,y:S))
 -(I(x:S),I(y:S)) -> O(-(x:S,y:S))
 -(x:S,0) -> x:S
 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:S),I(y:S)) -> -#(x:S,y:S)
 -#(I(x:S),O(y:S)) -> -#(x:S,y:S)
 -#(I(x:S),I(y:S)) -> -#(x:S,y:S)
-> Rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 -(O(x:S),O(y:S)) -> O(-(x:S,y:S))
 -(O(x:S),I(y:S)) -> I(-(-(x:S,y:S),I(1)))
 -(0,x:S) -> 0
 -(I(x:S),O(y:S)) -> I(-(x:S,y:S))
 -(I(x:S),I(y:S)) -> O(-(x:S,y:S))
 -(x:S,0) -> x:S
 BS(L(x:S)) -> ttrue
 BS(N(x:S,l,r)) -> and(and(ge(x:S,Max(l)),ge(Min(r),x:S)),and(BS(l),BS(r)))
 Log(x:S) -> -(Log'(x:S),I(0))
 Log'(O(x:S)) -> if(ge(x:S,I(0)),+(Log'(x:S),I(0)),0)
 Log'(0) -> 0
 Log'(I(x:S)) -> +(Log'(x:S),I(0))
 Max(L(x:S)) -> x:S
 Max(N(x:S,l,r)) -> Max(r)
 Min(L(x:S)) -> x:S
 Min(N(x:S,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x:S)) -> I(0)
 Size(N(x:S,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x:S)) -> x:S
 Val(N(x:S,l,r)) -> x:S
 WB(L(x:S)) -> ttrue
 WB(N(x:S,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:S,ffalse) -> ffalse
 and(x:S,ttrue) -> x:S
 ge(O(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(O(x:S),I(y:S)) -> not(ge(y:S,x:S))
 ge(0,O(x:S)) -> ge(0,x:S)
 ge(0,I(x:S)) -> ffalse
 ge(I(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(I(x:S),I(y:S)) -> ge(x:S,y:S)
 ge(x:S,0) -> ttrue
 if(ffalse,x:S,y:S) -> y:S
 if(ttrue,x:S,y:S) -> x:S
 not(ffalse) -> ttrue
 not(ttrue) -> ffalse
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 -#(O(x:S),I(y:S)) -> -#(x:S,y:S)
 -#(I(x:S),O(y:S)) -> -#(x:S,y:S)
 -#(I(x:S),I(y:S)) -> -#(x:S,y:S)
->->-> Rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 -(O(x:S),O(y:S)) -> O(-(x:S,y:S))
 -(O(x:S),I(y:S)) -> I(-(-(x:S,y:S),I(1)))
 -(0,x:S) -> 0
 -(I(x:S),O(y:S)) -> I(-(x:S,y:S))
 -(I(x:S),I(y:S)) -> O(-(x:S,y:S))
 -(x:S,0) -> x:S
 BS(L(x:S)) -> ttrue
 BS(N(x:S,l,r)) -> and(and(ge(x:S,Max(l)),ge(Min(r),x:S)),and(BS(l),BS(r)))
 Log(x:S) -> -(Log'(x:S),I(0))
 Log'(O(x:S)) -> if(ge(x:S,I(0)),+(Log'(x:S),I(0)),0)
 Log'(0) -> 0
 Log'(I(x:S)) -> +(Log'(x:S),I(0))
 Max(L(x:S)) -> x:S
 Max(N(x:S,l,r)) -> Max(r)
 Min(L(x:S)) -> x:S
 Min(N(x:S,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x:S)) -> I(0)
 Size(N(x:S,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x:S)) -> x:S
 Val(N(x:S,l,r)) -> x:S
 WB(L(x:S)) -> ttrue
 WB(N(x:S,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:S,ffalse) -> ffalse
 and(x:S,ttrue) -> x:S
 ge(O(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(O(x:S),I(y:S)) -> not(ge(y:S,x:S))
 ge(0,O(x:S)) -> ge(0,x:S)
 ge(0,I(x:S)) -> ffalse
 ge(I(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(I(x:S),I(y:S)) -> ge(x:S,y:S)
 ge(x:S,0) -> ttrue
 if(ffalse,x:S,y:S) -> y:S
 if(ttrue,x:S,y:S) -> x:S
 not(ffalse) -> ttrue
 not(ttrue) -> ffalse

Problem 1.3: 

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

Problem 1.3: 

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

The problem is finite.

Problem 1.4: 

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

Problem 1.4: 

Reduction Pair Processor:
-> Pairs:
 +#(O(x:S),I(y:S)) -> +#(x:S,y:S)
 +#(I(x:S),O(y:S)) -> +#(x:S,y:S)
 +#(I(x:S),I(y:S)) -> +#(+(x:S,y:S),I(0))
 +#(I(x:S),I(y:S)) -> +#(x:S,y:S)
 +#(x:S,+(y:S,z:S)) -> +#(+(x:S,y:S),z:S)
 +#(x:S,+(y:S,z:S)) -> +#(x:S,y:S)
-> Rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 -(O(x:S),O(y:S)) -> O(-(x:S,y:S))
 -(O(x:S),I(y:S)) -> I(-(-(x:S,y:S),I(1)))
 -(0,x:S) -> 0
 -(I(x:S),O(y:S)) -> I(-(x:S,y:S))
 -(I(x:S),I(y:S)) -> O(-(x:S,y:S))
 -(x:S,0) -> x:S
 BS(L(x:S)) -> ttrue
 BS(N(x:S,l,r)) -> and(and(ge(x:S,Max(l)),ge(Min(r),x:S)),and(BS(l),BS(r)))
 Log(x:S) -> -(Log'(x:S),I(0))
 Log'(O(x:S)) -> if(ge(x:S,I(0)),+(Log'(x:S),I(0)),0)
 Log'(0) -> 0
 Log'(I(x:S)) -> +(Log'(x:S),I(0))
 Max(L(x:S)) -> x:S
 Max(N(x:S,l,r)) -> Max(r)
 Min(L(x:S)) -> x:S
 Min(N(x:S,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x:S)) -> I(0)
 Size(N(x:S,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x:S)) -> x:S
 Val(N(x:S,l,r)) -> x:S
 WB(L(x:S)) -> ttrue
 WB(N(x:S,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:S,ffalse) -> ffalse
 and(x:S,ttrue) -> x:S
 ge(O(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(O(x:S),I(y:S)) -> not(ge(y:S,x:S))
 ge(0,O(x:S)) -> ge(0,x:S)
 ge(0,I(x:S)) -> ffalse
 ge(I(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(I(x:S),I(y:S)) -> ge(x:S,y:S)
 ge(x:S,0) -> ttrue
 if(ffalse,x:S,y:S) -> y:S
 if(ttrue,x:S,y:S) -> x:S
 not(ffalse) -> ttrue
 not(ttrue) -> ffalse
-> Usable rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 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 + X2

Problem 1.4: 

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

Problem 1.4: 

Reduction Pair Processor:
-> Pairs:
 +#(I(x:S),O(y:S)) -> +#(x:S,y:S)
 +#(I(x:S),I(y:S)) -> +#(+(x:S,y:S),I(0))
 +#(I(x:S),I(y:S)) -> +#(x:S,y:S)
 +#(x:S,+(y:S,z:S)) -> +#(+(x:S,y:S),z:S)
 +#(x:S,+(y:S,z:S)) -> +#(x:S,y:S)
-> Rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 -(O(x:S),O(y:S)) -> O(-(x:S,y:S))
 -(O(x:S),I(y:S)) -> I(-(-(x:S,y:S),I(1)))
 -(0,x:S) -> 0
 -(I(x:S),O(y:S)) -> I(-(x:S,y:S))
 -(I(x:S),I(y:S)) -> O(-(x:S,y:S))
 -(x:S,0) -> x:S
 BS(L(x:S)) -> ttrue
 BS(N(x:S,l,r)) -> and(and(ge(x:S,Max(l)),ge(Min(r),x:S)),and(BS(l),BS(r)))
 Log(x:S) -> -(Log'(x:S),I(0))
 Log'(O(x:S)) -> if(ge(x:S,I(0)),+(Log'(x:S),I(0)),0)
 Log'(0) -> 0
 Log'(I(x:S)) -> +(Log'(x:S),I(0))
 Max(L(x:S)) -> x:S
 Max(N(x:S,l,r)) -> Max(r)
 Min(L(x:S)) -> x:S
 Min(N(x:S,l,r)) -> Min(l)
 O(0) -> 0
 Size(L(x:S)) -> I(0)
 Size(N(x:S,l,r)) -> +(+(Size(l),Size(r)),I(1))
 Val(L(x:S)) -> x:S
 Val(N(x:S,l,r)) -> x:S
 WB(L(x:S)) -> ttrue
 WB(N(x:S,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:S,ffalse) -> ffalse
 and(x:S,ttrue) -> x:S
 ge(O(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(O(x:S),I(y:S)) -> not(ge(y:S,x:S))
 ge(0,O(x:S)) -> ge(0,x:S)
 ge(0,I(x:S)) -> ffalse
 ge(I(x:S),O(y:S)) -> ge(x:S,y:S)
 ge(I(x:S),I(y:S)) -> ge(x:S,y:S)
 ge(x:S,0) -> ttrue
 if(ffalse,x:S,y:S) -> y:S
 if(ttrue,x:S,y:S) -> x:S
 not(ffalse) -> ttrue
 not(ttrue) -> ffalse
-> Usable rules:
 +(O(x:S),O(y:S)) -> O(+(x:S,y:S))
 +(O(x:S),I(y:S)) -> I(+(x:S,y:S))
 +(0,x:S) -> x:S
 +(I(x:S),O(y:S)) -> I(+(x:S,y:S))
 +(I(x:S),I(y:S)) -> O(+(+(x:S,y:S),I(0)))
 +(x:S,+(y:S,z:S)) -> +(+(x:S,y:S),z:S)
 +(x:S,0) -> x:S
 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
[I](X) = X + 2
[+#](X1,X2) = X1 + 2.X2

Problem 1.4: 

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

Problem 1.4: 

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

Problem 1.4: 

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

Problem 1.4: 

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

Problem 1.4: 

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

The problem is finite.

Problem 1.5: 

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

Problem 1.5: 

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

The problem is finite.