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


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


MAYBE
We consider the system theBenchmark.

We are asked to determine termination of the following first-order TRS.

  0 : [] --> o 
  active : [o] --> o 
  add : [o * o] --> o 
  fact : [o] --> o 
  false : [] --> o 
  if : [o * o * o] --> o 
  mark : [o] --> o 
  ok : [o] --> o 
  p : [o] --> o 
  prod : [o * o] --> o 
  proper : [o] --> o 
  s : [o] --> o 
  top : [o] --> o 
  true : [] --> o 
  zero : [o] --> o 

  active(fact(X)) => mark(if(zero(X), s(0), prod(X, fact(p(X))))) 
  active(add(0, X)) => mark(X) 
  active(add(s(X), Y)) => mark(s(add(X, Y))) 
  active(prod(0, X)) => mark(0) 
  active(prod(s(X), Y)) => mark(add(Y, prod(X, Y))) 
  active(if(true, X, Y)) => mark(X) 
  active(if(false, X, Y)) => mark(Y) 
  active(zero(0)) => mark(true) 
  active(zero(s(X))) => mark(false) 
  active(p(s(X))) => mark(X) 
  active(fact(X)) => fact(active(X)) 
  active(if(X, Y, Z)) => if(active(X), Y, Z) 
  active(zero(X)) => zero(active(X)) 
  active(s(X)) => s(active(X)) 
  active(prod(X, Y)) => prod(active(X), Y) 
  active(prod(X, Y)) => prod(X, active(Y)) 
  active(p(X)) => p(active(X)) 
  active(add(X, Y)) => add(active(X), Y) 
  active(add(X, Y)) => add(X, active(Y)) 
  fact(mark(X)) => mark(fact(X)) 
  if(mark(X), Y, Z) => mark(if(X, Y, Z)) 
  zero(mark(X)) => mark(zero(X)) 
  s(mark(X)) => mark(s(X)) 
  prod(mark(X), Y) => mark(prod(X, Y)) 
  prod(X, mark(Y)) => mark(prod(X, Y)) 
  p(mark(X)) => mark(p(X)) 
  add(mark(X), Y) => mark(add(X, Y)) 
  add(X, mark(Y)) => mark(add(X, Y)) 
  proper(fact(X)) => fact(proper(X)) 
  proper(if(X, Y, Z)) => if(proper(X), proper(Y), proper(Z)) 
  proper(zero(X)) => zero(proper(X)) 
  proper(s(X)) => s(proper(X)) 
  proper(0) => ok(0) 
  proper(prod(X, Y)) => prod(proper(X), proper(Y)) 
  proper(p(X)) => p(proper(X)) 
  proper(add(X, Y)) => add(proper(X), proper(Y)) 
  proper(true) => ok(true) 
  proper(false) => ok(false) 
  fact(ok(X)) => ok(fact(X)) 
  if(ok(X), ok(Y), ok(Z)) => ok(if(X, Y, Z)) 
  zero(ok(X)) => ok(zero(X)) 
  s(ok(X)) => ok(s(X)) 
  prod(ok(X), ok(Y)) => ok(prod(X, Y)) 
  p(ok(X)) => ok(p(X)) 
  add(ok(X), ok(Y)) => ok(add(X, Y)) 
  top(mark(X)) => top(proper(X)) 
  top(ok(X)) => top(active(X))