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


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


NO

Problem 1: 

(VAR q r x y)
(RULES
div(x,y) -> pair(0,y) | greater(y,x) -> true
div(x,y) -> pair(s(q),r) | leq(y,x) -> true, div(m(x,y),y) -> pair(q,r)
greater(s(x),0) -> true
greater(s(x),s(y)) -> greater(x,y)
leq(0,x) -> true
leq(s(x),s(y)) -> leq(x,y)
m(0,y) -> 0
m(s(x),s(y)) -> m(x,y)
m(x,0) -> x
)

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

Problem 1: 

Dependency Pairs Processor:

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

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

Problem 1: 

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

Problem 1: 

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

Problem 1: 

SCC Processor:
-> Pairs:
 DIV(s(y),s(x)) -> DIV(m(s(y),s(x)),s(x)) | leq(x,y) -> true
 DIV(x4,0) -> DIV(m(x4,0),0) | true -> true
-> QPairs:
 Empty
-> Rules:
 div(x,y) -> pair(0,y) | greater(y,x) -> true
 div(x,y) -> pair(s(q),r) | leq(y,x) -> true, div(m(x,y),y) -> pair(q,r)
 greater(s(x),0) -> true
 greater(s(x),s(y)) -> greater(x,y)
 leq(0,x) -> true
 leq(s(x),s(y)) -> leq(x,y)
 m(0,y) -> 0
 m(s(x),s(y)) -> m(x,y)
 m(x,0) -> x
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIV(x4,0) -> DIV(m(x4,0),0) | true -> true
->->-> Rules:
 div(x,y) -> pair(0,y) | greater(y,x) -> true
 div(x,y) -> pair(s(q),r) | leq(y,x) -> true, div(m(x,y),y) -> pair(q,r)
 greater(s(x),0) -> true
 greater(s(x),s(y)) -> greater(x,y)
 leq(0,x) -> true
 leq(s(x),s(y)) -> leq(x,y)
 m(0,y) -> 0
 m(s(x),s(y)) -> m(x,y)
 m(x,0) -> x
->->Cycle:
->->-> Pairs:
 DIV(s(y),s(x)) -> DIV(m(s(y),s(x)),s(x)) | leq(x,y) -> true
->->-> Rules:
 div(x,y) -> pair(0,y) | greater(y,x) -> true
 div(x,y) -> pair(s(q),r) | leq(y,x) -> true, div(m(x,y),y) -> pair(q,r)
 greater(s(x),0) -> true
 greater(s(x),s(y)) -> greater(x,y)
 leq(0,x) -> true
 leq(s(x),s(y)) -> leq(x,y)
 m(0,y) -> 0
 m(s(x),s(y)) -> m(x,y)
 m(x,0) -> x

Problem 1: 

Simplifying Unifiable Condition Processor:
-> Pairs:
 DIV(x4,0) -> DIV(m(x4,0),0) | true -> true
-> QPairs:
 Empty
-> Rules:
 div(x,y) -> pair(0,y) | greater(y,x) -> true
 div(x,y) -> pair(s(q),r) | leq(y,x) -> true, div(m(x,y),y) -> pair(q,r)
 greater(s(x),0) -> true
 greater(s(x),s(y)) -> greater(x,y)
 leq(0,x) -> true
 leq(s(x),s(y)) -> leq(x,y)
 m(0,y) -> 0
 m(s(x),s(y)) -> m(x,y)
 m(x,0) -> x
->Transformed Pairs:
->->Original Pair:
 DIV(x4,0) -> DIV(m(x4,0),0) | true -> true
->-> Transformed Pair:
 DIV(x4,0) -> DIV(m(x4,0),0)

Problem 1: 

Infinite Processor:
-> Pairs:
 DIV(x4,0) -> DIV(m(x4,0),0)
-> QPairs:
 Empty
-> Rules:
 div(x,y) -> pair(0,y) | greater(y,x) -> true
 div(x,y) -> pair(s(q),r) | leq(y,x) -> true, div(m(x,y),y) -> pair(q,r)
 greater(s(x),0) -> true
 greater(s(x),s(y)) -> greater(x,y)
 leq(0,x) -> true
 leq(s(x),s(y)) -> leq(x,y)
 m(0,y) -> 0
 m(s(x),s(y)) -> m(x,y)
 m(x,0) -> x
-> Pairs in cycle:
 DIV(x4,0) -> DIV(m(x4,0),0)

The problem is infinite.