/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 X1 X2 X3 Y)
(RULES
active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
active(div(0,s(Y))) -> mark(0)
active(geq(s(X),s(Y))) -> mark(geq(X,Y))
active(geq(0,s(Y))) -> mark(false)
active(geq(X,0)) -> mark(true)
active(if(false,X,Y)) -> mark(Y)
active(if(true,X,Y)) -> mark(X)
active(minus(s(X),s(Y))) -> mark(minus(X,Y))
active(minus(0,Y)) -> mark(0)
div(active(X1),X2) -> div(X1,X2)
div(mark(X1),X2) -> div(X1,X2)
div(X1,active(X2)) -> div(X1,X2)
div(X1,mark(X2)) -> div(X1,X2)
geq(active(X1),X2) -> geq(X1,X2)
geq(mark(X1),X2) -> geq(X1,X2)
geq(X1,active(X2)) -> geq(X1,X2)
geq(X1,mark(X2)) -> geq(X1,X2)
if(active(X1),X2,X3) -> if(X1,X2,X3)
if(mark(X1),X2,X3) -> if(X1,X2,X3)
if(X1,active(X2),X3) -> if(X1,X2,X3)
if(X1,mark(X2),X3) -> if(X1,X2,X3)
if(X1,X2,active(X3)) -> if(X1,X2,X3)
if(X1,X2,mark(X3)) -> if(X1,X2,X3)
mark(div(X1,X2)) -> active(div(mark(X1),X2))
mark(geq(X1,X2)) -> active(geq(X1,X2))
mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
mark(minus(X1,X2)) -> active(minus(X1,X2))
mark(s(X)) -> active(s(mark(X)))
mark(0) -> active(0)
mark(false) -> active(false)
mark(true) -> active(true)
minus(active(X1),X2) -> minus(X1,X2)
minus(mark(X1),X2) -> minus(X1,X2)
minus(X1,active(X2)) -> minus(X1,X2)
minus(X1,mark(X2)) -> minus(X1,X2)
s(active(X)) -> s(X)
s(mark(X)) -> s(X)
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 ACTIVE(div(s(X),s(Y))) -> DIV(minus(X,Y),s(Y))
 ACTIVE(div(s(X),s(Y))) -> GEQ(X,Y)
 ACTIVE(div(s(X),s(Y))) -> IF(geq(X,Y),s(div(minus(X,Y),s(Y))),0)
 ACTIVE(div(s(X),s(Y))) -> MARK(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 ACTIVE(div(s(X),s(Y))) -> MINUS(X,Y)
 ACTIVE(div(s(X),s(Y))) -> S(div(minus(X,Y),s(Y)))
 ACTIVE(div(0,s(Y))) -> MARK(0)
 ACTIVE(geq(s(X),s(Y))) -> GEQ(X,Y)
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(geq(0,s(Y))) -> MARK(false)
 ACTIVE(geq(X,0)) -> MARK(true)
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 ACTIVE(minus(s(X),s(Y))) -> MINUS(X,Y)
 ACTIVE(minus(0,Y)) -> MARK(0)
 DIV(active(X1),X2) -> DIV(X1,X2)
 DIV(mark(X1),X2) -> DIV(X1,X2)
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
 GEQ(active(X1),X2) -> GEQ(X1,X2)
 GEQ(mark(X1),X2) -> GEQ(X1,X2)
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
 IF(active(X1),X2,X3) -> IF(X1,X2,X3)
 IF(mark(X1),X2,X3) -> IF(X1,X2,X3)
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> DIV(mark(X1),X2)
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> IF(mark(X1),X2,X3)
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
 MARK(s(X)) -> S(mark(X))
 MINUS(active(X1),X2) -> MINUS(X1,X2)
 MINUS(mark(X1),X2) -> MINUS(X1,X2)
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
 S(active(X)) -> S(X)
 S(mark(X)) -> S(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1: 

SCC Processor:
-> Pairs:
 ACTIVE(div(s(X),s(Y))) -> DIV(minus(X,Y),s(Y))
 ACTIVE(div(s(X),s(Y))) -> GEQ(X,Y)
 ACTIVE(div(s(X),s(Y))) -> IF(geq(X,Y),s(div(minus(X,Y),s(Y))),0)
 ACTIVE(div(s(X),s(Y))) -> MARK(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 ACTIVE(div(s(X),s(Y))) -> MINUS(X,Y)
 ACTIVE(div(s(X),s(Y))) -> S(div(minus(X,Y),s(Y)))
 ACTIVE(div(0,s(Y))) -> MARK(0)
 ACTIVE(geq(s(X),s(Y))) -> GEQ(X,Y)
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(geq(0,s(Y))) -> MARK(false)
 ACTIVE(geq(X,0)) -> MARK(true)
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 ACTIVE(minus(s(X),s(Y))) -> MINUS(X,Y)
 ACTIVE(minus(0,Y)) -> MARK(0)
 DIV(active(X1),X2) -> DIV(X1,X2)
 DIV(mark(X1),X2) -> DIV(X1,X2)
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
 GEQ(active(X1),X2) -> GEQ(X1,X2)
 GEQ(mark(X1),X2) -> GEQ(X1,X2)
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
 IF(active(X1),X2,X3) -> IF(X1,X2,X3)
 IF(mark(X1),X2,X3) -> IF(X1,X2,X3)
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> DIV(mark(X1),X2)
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> IF(mark(X1),X2,X3)
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
 MARK(s(X)) -> S(mark(X))
 MINUS(active(X1),X2) -> MINUS(X1,X2)
 MINUS(mark(X1),X2) -> MINUS(X1,X2)
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
 S(active(X)) -> S(X)
 S(mark(X)) -> S(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 S(active(X)) -> S(X)
 S(mark(X)) -> S(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->->Cycle:
->->-> Pairs:
 MINUS(active(X1),X2) -> MINUS(X1,X2)
 MINUS(mark(X1),X2) -> MINUS(X1,X2)
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->->Cycle:
->->-> Pairs:
 IF(active(X1),X2,X3) -> IF(X1,X2,X3)
 IF(mark(X1),X2,X3) -> IF(X1,X2,X3)
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->->Cycle:
->->-> Pairs:
 GEQ(active(X1),X2) -> GEQ(X1,X2)
 GEQ(mark(X1),X2) -> GEQ(X1,X2)
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->->Cycle:
->->-> Pairs:
 DIV(active(X1),X2) -> DIV(X1,X2)
 DIV(mark(X1),X2) -> DIV(X1,X2)
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->->Cycle:
->->-> Pairs:
 ACTIVE(div(s(X),s(Y))) -> MARK(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)


The problem is decomposed in 6 subproblems.

Problem 1.1: 

Subterm Processor:
-> Pairs:
 S(active(X)) -> S(X)
 S(mark(X)) -> S(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(S) = 1

Problem 1.1: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

Subterm Processor:
-> Pairs:
 MINUS(active(X1),X2) -> MINUS(X1,X2)
 MINUS(mark(X1),X2) -> MINUS(X1,X2)
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(MINUS) = 1

Problem 1.2: 

SCC Processor:
-> Pairs:
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.2: 

Subterm Processor:
-> Pairs:
 MINUS(X1,active(X2)) -> MINUS(X1,X2)
 MINUS(X1,mark(X2)) -> MINUS(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(MINUS) = 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.3: 

Subterm Processor:
-> Pairs:
 IF(active(X1),X2,X3) -> IF(X1,X2,X3)
 IF(mark(X1),X2,X3) -> IF(X1,X2,X3)
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(IF) = 1

Problem 1.3: 

SCC Processor:
-> Pairs:
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.3: 

Subterm Processor:
-> Pairs:
 IF(X1,active(X2),X3) -> IF(X1,X2,X3)
 IF(X1,mark(X2),X3) -> IF(X1,X2,X3)
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(IF) = 2

Problem 1.3: 

SCC Processor:
-> Pairs:
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.3: 

Subterm Processor:
-> Pairs:
 IF(X1,X2,active(X3)) -> IF(X1,X2,X3)
 IF(X1,X2,mark(X3)) -> IF(X1,X2,X3)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(IF) = 3

Problem 1.3: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.4: 

Subterm Processor:
-> Pairs:
 GEQ(active(X1),X2) -> GEQ(X1,X2)
 GEQ(mark(X1),X2) -> GEQ(X1,X2)
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(GEQ) = 1

Problem 1.4: 

SCC Processor:
-> Pairs:
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.4: 

Subterm Processor:
-> Pairs:
 GEQ(X1,active(X2)) -> GEQ(X1,X2)
 GEQ(X1,mark(X2)) -> GEQ(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(GEQ) = 2

Problem 1.4: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.5: 

Subterm Processor:
-> Pairs:
 DIV(active(X1),X2) -> DIV(X1,X2)
 DIV(mark(X1),X2) -> DIV(X1,X2)
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(DIV) = 1

Problem 1.5: 

SCC Processor:
-> Pairs:
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.5: 

Subterm Processor:
-> Pairs:
 DIV(X1,active(X2)) -> DIV(X1,X2)
 DIV(X1,mark(X2)) -> DIV(X1,X2)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(DIV) = 2

Problem 1.5: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.6: 

Reduction Pair Processor:
-> Pairs:
 ACTIVE(div(s(X),s(Y))) -> MARK(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
-> Usable rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[div](X1,X2) = 2.X1 + 2.X2 + 2
[geq](X1,X2) = 0
[if](X1,X2,X3) = 2.X1 + X2 + X3
[mark](X) = X
[minus](X1,X2) = 0
[s](X) = X + 1
[0] = 0
[false] = 0
[true] = 0
[ACTIVE](X) = 2.X + 2
[MARK](X) = 2.X + 2

Problem 1.6: 

SCC Processor:
-> Pairs:
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.6: 

Reduction Pair Processor:
-> Pairs:
 ACTIVE(geq(s(X),s(Y))) -> MARK(geq(X,Y))
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
-> Usable rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[div](X1,X2) = 2.X1 + 2
[geq](X1,X2) = X1
[if](X1,X2,X3) = 2.X1 + X2 + 2.X3
[mark](X) = X
[minus](X1,X2) = 0
[s](X) = 2.X + 2
[0] = 0
[false] = 0
[true] = 0
[ACTIVE](X) = 2.X + 2
[MARK](X) = 2.X + 2

Problem 1.6: 

SCC Processor:
-> Pairs:
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.6: 

Reduction Pair Processor:
-> Pairs:
 ACTIVE(if(false,X,Y)) -> MARK(Y)
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
-> Usable rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[div](X1,X2) = 2.X1 + 1
[geq](X1,X2) = 2.X1 + 1
[if](X1,X2,X3) = X1 + X2 + X3
[mark](X) = X
[minus](X1,X2) = 0
[s](X) = 2.X + 2
[0] = 0
[false] = 1
[true] = 1
[ACTIVE](X) = 2.X + 2
[MARK](X) = 2.X + 2

Problem 1.6: 

SCC Processor:
-> Pairs:
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.6: 

Reduction Pair Processor:
-> Pairs:
 ACTIVE(if(true,X,Y)) -> MARK(X)
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
-> Usable rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[div](X1,X2) = 2.X1 + 1
[geq](X1,X2) = 2.X1 + 1
[if](X1,X2,X3) = X1 + X2 + 2.X3
[mark](X) = X
[minus](X1,X2) = 0
[s](X) = 2.X + 2
[0] = 0
[false] = 1
[true] = 1
[ACTIVE](X) = X + 1
[MARK](X) = X + 1

Problem 1.6: 

SCC Processor:
-> Pairs:
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.6: 

Reduction Pair Processor:
-> Pairs:
 ACTIVE(minus(s(X),s(Y))) -> MARK(minus(X,Y))
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
-> Usable rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[div](X1,X2) = 2.X1 + 2
[geq](X1,X2) = 0
[if](X1,X2,X3) = 2.X1 + X2 + 2.X3
[mark](X) = X
[minus](X1,X2) = X1
[s](X) = 2.X + 2
[0] = 0
[false] = 0
[true] = 0
[ACTIVE](X) = 2.X
[MARK](X) = 2.X + 2

Problem 1.6: 

SCC Processor:
-> Pairs:
 MARK(div(X1,X2)) -> ACTIVE(div(mark(X1),X2))
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(geq(X1,X2)) -> ACTIVE(geq(X1,X2))
 MARK(if(X1,X2,X3)) -> ACTIVE(if(mark(X1),X2,X3))
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(minus(X1,X2)) -> ACTIVE(minus(X1,X2))
 MARK(s(X)) -> ACTIVE(s(mark(X)))
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(s(X)) -> MARK(X)
->->-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)

Problem 1.6: 

Subterm Processor:
-> Pairs:
 MARK(div(X1,X2)) -> MARK(X1)
 MARK(if(X1,X2,X3)) -> MARK(X1)
 MARK(s(X)) -> MARK(X)
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Projection:
 pi(MARK) = 1

Problem 1.6: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(div(s(X),s(Y))) -> mark(if(geq(X,Y),s(div(minus(X,Y),s(Y))),0))
 active(div(0,s(Y))) -> mark(0)
 active(geq(s(X),s(Y))) -> mark(geq(X,Y))
 active(geq(0,s(Y))) -> mark(false)
 active(geq(X,0)) -> mark(true)
 active(if(false,X,Y)) -> mark(Y)
 active(if(true,X,Y)) -> mark(X)
 active(minus(s(X),s(Y))) -> mark(minus(X,Y))
 active(minus(0,Y)) -> mark(0)
 div(active(X1),X2) -> div(X1,X2)
 div(mark(X1),X2) -> div(X1,X2)
 div(X1,active(X2)) -> div(X1,X2)
 div(X1,mark(X2)) -> div(X1,X2)
 geq(active(X1),X2) -> geq(X1,X2)
 geq(mark(X1),X2) -> geq(X1,X2)
 geq(X1,active(X2)) -> geq(X1,X2)
 geq(X1,mark(X2)) -> geq(X1,X2)
 if(active(X1),X2,X3) -> if(X1,X2,X3)
 if(mark(X1),X2,X3) -> if(X1,X2,X3)
 if(X1,active(X2),X3) -> if(X1,X2,X3)
 if(X1,mark(X2),X3) -> if(X1,X2,X3)
 if(X1,X2,active(X3)) -> if(X1,X2,X3)
 if(X1,X2,mark(X3)) -> if(X1,X2,X3)
 mark(div(X1,X2)) -> active(div(mark(X1),X2))
 mark(geq(X1,X2)) -> active(geq(X1,X2))
 mark(if(X1,X2,X3)) -> active(if(mark(X1),X2,X3))
 mark(minus(X1,X2)) -> active(minus(X1,X2))
 mark(s(X)) -> active(s(mark(X)))
 mark(0) -> active(0)
 mark(false) -> active(false)
 mark(true) -> active(true)
 minus(active(X1),X2) -> minus(X1,X2)
 minus(mark(X1),X2) -> minus(X1,X2)
 minus(X1,active(X2)) -> minus(X1,X2)
 minus(X1,mark(X2)) -> minus(X1,X2)
 s(active(X)) -> s(X)
 s(mark(X)) -> s(X)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.