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


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


NO

Problem 1: 

(VAR v_NonEmpty:S q:S r:S x:S y:S)
(RULES
div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
greater(s(x:S),0) -> ttrue
greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
leq(0,x:S) -> ttrue
leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
m(0,y:S) -> 0
m(s(x:S),s(y:S)) -> m(x:S,y:S)
m(x:S,0) -> x:S
)

Problem 1: 
Valid CTRS Processor:
-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S
-> The system is a deterministic 3-CTRS.

Problem 1: 

Dependency Pairs Processor:

Conditional Termination Problem 1:
-> Pairs:
 GREATER(s(x:S),s(y:S)) -> GREATER(x:S,y:S)
 LEQ(s(x:S),s(y:S)) -> LEQ(x:S,y:S)
 M(s(x:S),s(y:S)) -> M(x:S,y:S)
-> QPairs:
 Empty
-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S

Conditional Termination Problem 2:
-> Pairs:
 DIV(x:S,y:S) -> DIV(m(x:S,y:S),y:S) | leq(y:S,x:S) ->* ttrue
 DIV(x:S,y:S) -> GREATER(y:S,x:S)
 DIV(x:S,y:S) -> LEQ(y:S,x:S)
 DIV(x:S,y:S) -> M(x:S,y:S) | leq(y:S,x:S) ->* ttrue
-> QPairs:
 GREATER(s(x:S),s(y:S)) -> GREATER(x:S,y:S)
 LEQ(s(x:S),s(y:S)) -> LEQ(x:S,y:S)
 M(s(x:S),s(y:S)) -> M(x:S,y:S)
-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S

Problem 1: 

SCC Processor:
-> Pairs:
 DIV(x:S,y:S) -> DIV(m(x:S,y:S),y:S) | leq(y:S,x:S) ->* ttrue
 DIV(x:S,y:S) -> GREATER(y:S,x:S)
 DIV(x:S,y:S) -> LEQ(y:S,x:S)
 DIV(x:S,y:S) -> M(x:S,y:S) | leq(y:S,x:S) ->* ttrue
-> QPairs:
 GREATER(s(x:S),s(y:S)) -> GREATER(x:S,y:S)
 LEQ(s(x:S),s(y:S)) -> LEQ(x:S,y:S)
 M(s(x:S),s(y:S)) -> M(x:S,y:S)
-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIV(x:S,y:S) -> DIV(m(x:S,y:S),y:S) | leq(y:S,x:S) ->* ttrue
-> QPairs:
 Empty
->->-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S

Problem 1: 

Narrowing on Condition Processor:
-> Pairs:
 DIV(x:S,y:S) -> DIV(m(x:S,y:S),y:S) | leq(y:S,x:S) ->* ttrue
-> QPairs:
 Empty
-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S
->Narrowed Pairs:
->->Original Pair:
 DIV(x:S,y:S) -> DIV(m(x:S,y:S),y:S) | leq(y:S,x:S) ->* ttrue
->-> Narrowed pairs:
 DIV(x5:S,x6:S) -> DIV(m(x5:S,x6:S),x6:S) | x5:S ->* s(y:S), x6:S ->* s(x:S), leq(x:S,y:S) ->* ttrue
 DIV(x5:S,x6:S) -> DIV(m(x5:S,x6:S),x6:S) | x5:S ->* x5:S, x6:S ->* 0, ttrue ->* ttrue

Problem 1: 

Infinite Processor:
-> Pairs:
 DIV(x5:S,x6:S) -> DIV(m(x5:S,x6:S),x6:S) | x5:S ->* s(y:S), x6:S ->* s(x:S), leq(x:S,y:S) ->* ttrue
 DIV(x5:S,x6:S) -> DIV(m(x5:S,x6:S),x6:S) | x5:S ->* x5:S, x6:S ->* 0, ttrue ->* ttrue
-> QPairs:
 Empty
-> Rules:
 div(x:S,y:S) -> pair(0,y:S) | greater(y:S,x:S) ->* ttrue
 div(x:S,y:S) -> pair(s(q:S),r:S) | leq(y:S,x:S) ->* ttrue, div(m(x:S,y:S),y:S) ->* pair(q:S,r:S)
 greater(s(x:S),0) -> ttrue
 greater(s(x:S),s(y:S)) -> greater(x:S,y:S)
 leq(0,x:S) -> ttrue
 leq(s(x:S),s(y:S)) -> leq(x:S,y:S)
 m(0,y:S) -> 0
 m(s(x:S),s(y:S)) -> m(x:S,y:S)
 m(x:S,0) -> x:S
-> Pairs in cycle:
 DIV(x5:S,x6:S) -> DIV(m(x5:S,x6:S),x6:S) | x5:S ->* x5:S, x6:S ->* 0, ttrue ->* ttrue

The problem is infinite.