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


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


MAYBE

We split firstr-order part and higher-order part, and do modular checking by a general modularity.

******** FO SN check ********
Check SN using NaTT (Nagoya Termination Tool)
Input TRS:
    1: if(true(),X,Y) -> X
    2: if(false(),U,V) -> V
    3: _(X1,X2) -> X1
    4: _(X1,X2) -> X2
Number of strict rules: 4
Direct POLO(bPol) ... removes: 4 1 3 2
      false	w: 7720
      _ 	w: x1 + 2 * x2 + 1
      true	w: 1
      if	w: 2 * x1 + 2 * x2 + 2 * x3
Number of strict rules: 0

...
Input TRS:
    1: if(true(),X,Y) -> X
    2: if(false(),U,V) -> V
    3: _(X1,X2) -> X1
    4: _(X1,X2) -> X2
Number of strict rules: 4
Direct POLO(bPol) ... removes: 4 1 3 2
      false	w: 7720
      _ 	w: x1 + 2 * x2 + 1
      true	w: 1
      if	w: 2 * x1 + 2 * x2 + 2 * x3
Number of strict rules: 0
>>YES

******** Signature ********
 until : ((b -> a),(b -> b),b) -> b
 if : (a,b,b) -> b
******** Computation rules ********
 (3)  until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))


******** General Schema criterion ********
Found constructors: false, true
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
Checking  (1) if(true,X,Y) => X
 (meta X)[is acc in true,X,Y] [is positive in true] [is acc in X]  >>True
Checking  (2) if(false,U,V) => V
 (meta V)[is acc in false,U,V] [is positive in false] [is acc in V]  >>True
Checking  (3) until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))
 (fun until>if)
 (meta J)[is acc in J,I,X1] [is acc in J] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (fun until=until) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (1) if(true,X,Y) => X
 (meta X)[is acc in true,X,Y] [is positive in true] [is acc in X]  >>True
Checking  (2) if(false,U,V) => V
 (meta V)[is acc in false,U,V] [is positive in false] [is acc in V]  >>True
Checking  (3) until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))
 (fun until>if)
 (meta J)[is acc in J,I,X1] [is acc in J] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (fun until=until) subterm comparison of args w. RL RL >>False

Try again using status Mul
Checking  (1) if(true,X,Y) => X
 (meta X)[is acc in true,X,Y] [is positive in true] [is acc in X]  >>True
Checking  (2) if(false,U,V) => V
 (meta V)[is acc in false,U,V] [is positive in false] [is acc in V]  >>True
Checking  (3) until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))
 (fun until>if)
 (meta J)[is acc in J,I,X1] [is acc in J] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (fun until=until) subterm comparison of args w. Mul Mul >>False
Found constructors: if
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
Checking  (3) until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))
 (fun until>if)
 (meta J)[is acc in J,I,X1] [is acc in J] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (fun until=until) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (3) until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))
 (fun until>if)
 (meta J)[is acc in J,I,X1] [is acc in J] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (fun until=until) subterm comparison of args w. RL RL >>False

Try again using status Mul
Checking  (3) until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))
 (fun until>if)
 (meta J)[is acc in J,I,X1] [is acc in J] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (meta X1)[is acc in J,I,X1] [is acc in X1] 
 (fun until=until) subterm comparison of args w. Mul Mul >>False
#No idea..
******** Signature ********
 false : a
 if : (a,b,b) -> b
 true : a
 until : ((b -> a),(b -> b),b) -> b
******** Computation Rules ********
 (1)  if(true,X,Y) => X
 (2)  if(false,U,V) => V
 (3)  until(J,I,X1) => if(J[X1],X1,until(J,I,I[X1]))

MAYBE