/export/starexec/sandbox/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


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


YES

Problem:
 minus(0()) -> 0()
 +(x,0()) -> x
 +(0(),y) -> y
 +(minus(1()),1()) -> 0()
 minus(minus(x)) -> x
 +(x,minus(y)) -> minus(+(minus(x),y))
 +(x,+(y,z)) -> +(+(x,y),z)
 +(minus(+(x,1())),1()) -> minus(x)

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [1] = 3,
   
   [+](x0, x1) = x0 + 4x1 + 1,
   
   [minus](x0) = x0,
   
   [0] = 1
  orientation:
   minus(0()) = 1 >= 1 = 0()
   
   +(x,0()) = x + 5 >= x = x
   
   +(0(),y) = 4y + 2 >= y = y
   
   +(minus(1()),1()) = 16 >= 1 = 0()
   
   minus(minus(x)) = x >= x = x
   
   +(x,minus(y)) = x + 4y + 1 >= x + 4y + 1 = minus(+(minus(x),y))
   
   +(x,+(y,z)) = x + 4y + 16z + 5 >= x + 4y + 4z + 2 = +(+(x,y),z)
   
   +(minus(+(x,1())),1()) = x + 26 >= x = minus(x)
  problem:
   minus(0()) -> 0()
   minus(minus(x)) -> x
   +(x,minus(y)) -> minus(+(minus(x),y))
  Matrix Interpretation Processor: dim=3
   
   interpretation:
                  [1 0 0]     [1 1 1]  
    [+](x0, x1) = [0 0 0]x0 + [0 1 0]x1
                  [0 0 0]     [0 0 1]  ,
    
                  [1 0 0]     [0]
    [minus](x0) = [0 0 1]x0 + [0]
                  [0 1 0]     [1],
    
          [1]
    [0] = [0]
          [0]
   orientation:
                 [1]    [1]      
    minus(0()) = [0] >= [0] = 0()
                 [1]    [0]      
    
                          [0]         
    minus(minus(x)) = x + [1] >= x = x
                          [1]         
    
                    [1 0 0]    [1 1 1]    [1]    [1 0 0]    [1 1 1]    [0]                       
    +(x,minus(y)) = [0 0 0]x + [0 0 1]y + [0] >= [0 0 0]x + [0 0 1]y + [0] = minus(+(minus(x),y))
                    [0 0 0]    [0 1 0]    [1]    [0 0 0]    [0 1 0]    [1]                       
   problem:
    minus(0()) -> 0()
    minus(minus(x)) -> x
   Matrix Interpretation Processor: dim=3
    
    interpretation:
                   [1 0 1]  
     [minus](x0) = [0 0 1]x0
                   [0 1 0]  ,
     
           [0]
     [0] = [1]
           [1]
    orientation:
                  [1]    [0]      
     minus(0()) = [1] >= [1] = 0()
                  [1]    [1]      
     
                       [1 1 1]          
     minus(minus(x)) = [0 1 0]x >= x = x
                       [0 0 1]          
    problem:
     minus(minus(x)) -> x
    Matrix Interpretation Processor: dim=3
     
     interpretation:
                    [1 0 1]     [0]
      [minus](x0) = [0 0 1]x0 + [0]
                    [0 1 0]     [1]
     orientation:
                        [1 1 1]    [1]         
      minus(minus(x)) = [0 1 0]x + [1] >= x = x
                        [0 0 1]    [1]         
     problem:
      
     Qed