/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 
  p : [o] --> o 
  prod : [o * o] --> o 
  s : [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) 
  mark(fact(X)) => active(fact(mark(X))) 
  mark(if(X, Y, Z)) => active(if(mark(X), Y, Z)) 
  mark(zero(X)) => active(zero(mark(X))) 
  mark(s(X)) => active(s(mark(X))) 
  mark(0) => active(0) 
  mark(prod(X, Y)) => active(prod(mark(X), mark(Y))) 
  mark(p(X)) => active(p(mark(X))) 
  mark(add(X, Y)) => active(add(mark(X), mark(Y))) 
  mark(true) => active(true) 
  mark(false) => active(false) 
  fact(mark(X)) => fact(X) 
  fact(active(X)) => fact(X) 
  if(mark(X), Y, Z) => if(X, Y, Z) 
  if(X, mark(Y), Z) => if(X, Y, Z) 
  if(X, Y, mark(Z)) => if(X, Y, Z) 
  if(active(X), Y, Z) => if(X, Y, Z) 
  if(X, active(Y), Z) => if(X, Y, Z) 
  if(X, Y, active(Z)) => if(X, Y, Z) 
  zero(mark(X)) => zero(X) 
  zero(active(X)) => zero(X) 
  s(mark(X)) => s(X) 
  s(active(X)) => s(X) 
  prod(mark(X), Y) => prod(X, Y) 
  prod(X, mark(Y)) => prod(X, Y) 
  prod(active(X), Y) => prod(X, Y) 
  prod(X, active(Y)) => prod(X, Y) 
  p(mark(X)) => p(X) 
  p(active(X)) => p(X) 
  add(mark(X), Y) => add(X, Y) 
  add(X, mark(Y)) => add(X, Y) 
  add(active(X), Y) => add(X, Y) 
  add(X, active(Y)) => add(X, Y)