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


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


YES

Problem:
 top(free(x)) -> top(check(new(x)))
 new(free(x)) -> free(new(x))
 old(free(x)) -> free(old(x))
 new(serve()) -> free(serve())
 old(serve()) -> free(serve())
 check(free(x)) -> free(check(x))
 check(new(x)) -> new(check(x))
 check(old(x)) -> old(check(x))
 check(old(x)) -> old(x)

Proof:
 Matrix Interpretation Processor: dim=3
  
  interpretation:
             [1]
   [serve] = [0]
             [0],
   
               [1 0 1]  
   [old](x0) = [0 0 0]x0
               [1 0 1]  ,
   
                 [1 0 0]  
   [check](x0) = [0 0 0]x0
                 [0 0 1]  ,
   
               [1 0 0]  
   [new](x0) = [0 0 0]x0
               [1 0 1]  ,
   
               [1 0 0]  
   [top](x0) = [0 0 0]x0
               [0 0 0]  ,
   
                [1 0 0]     [0]
   [free](x0) = [0 0 0]x0 + [0]
                [0 0 1]     [1]
  orientation:
                  [1 0 0]     [1 0 0]                      
   top(free(x)) = [0 0 0]x >= [0 0 0]x = top(check(new(x)))
                  [0 0 0]     [0 0 0]                      
   
                  [1 0 0]    [0]    [1 0 0]    [0]               
   new(free(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = free(new(x))
                  [1 0 1]    [1]    [1 0 1]    [1]               
   
                  [1 0 1]    [1]    [1 0 1]    [0]               
   old(free(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = free(old(x))
                  [1 0 1]    [1]    [1 0 1]    [1]               
   
                  [1]    [1]                
   new(serve()) = [0] >= [0] = free(serve())
                  [1]    [1]                
   
                  [1]    [1]                
   old(serve()) = [0] >= [0] = free(serve())
                  [1]    [1]                
   
                    [1 0 0]    [0]    [1 0 0]    [0]                 
   check(free(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = free(check(x))
                    [0 0 1]    [1]    [0 0 1]    [1]                 
   
                   [1 0 0]     [1 0 0]                 
   check(new(x)) = [0 0 0]x >= [0 0 0]x = new(check(x))
                   [1 0 1]     [1 0 1]                 
   
                   [1 0 1]     [1 0 1]                 
   check(old(x)) = [0 0 0]x >= [0 0 0]x = old(check(x))
                   [1 0 1]     [1 0 1]                 
   
                   [1 0 1]     [1 0 1]          
   check(old(x)) = [0 0 0]x >= [0 0 0]x = old(x)
                   [1 0 1]     [1 0 1]          
  problem:
   top(free(x)) -> top(check(new(x)))
   new(free(x)) -> free(new(x))
   new(serve()) -> free(serve())
   old(serve()) -> free(serve())
   check(free(x)) -> free(check(x))
   check(new(x)) -> new(check(x))
   check(old(x)) -> old(check(x))
   check(old(x)) -> old(x)
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [serve] = 0,
    
    [old](x0) = x0 + 1,
    
    [check](x0) = 2x0,
    
    [new](x0) = 2x0,
    
    [top](x0) = x0,
    
    [free](x0) = 4x0
   orientation:
    top(free(x)) = 4x >= 4x = top(check(new(x)))
    
    new(free(x)) = 8x >= 8x = free(new(x))
    
    new(serve()) = 0 >= 0 = free(serve())
    
    old(serve()) = 1 >= 0 = free(serve())
    
    check(free(x)) = 8x >= 8x = free(check(x))
    
    check(new(x)) = 4x >= 4x = new(check(x))
    
    check(old(x)) = 2x + 2 >= 2x + 1 = old(check(x))
    
    check(old(x)) = 2x + 2 >= x + 1 = old(x)
   problem:
    top(free(x)) -> top(check(new(x)))
    new(free(x)) -> free(new(x))
    new(serve()) -> free(serve())
    check(free(x)) -> free(check(x))
    check(new(x)) -> new(check(x))
   Matrix Interpretation Processor: dim=3
    
    interpretation:
               [0]
     [serve] = [1]
               [0],
     
                   [1 0 0]  
     [check](x0) = [0 0 0]x0
                   [0 0 1]  ,
     
                 [1 0 0]  
     [new](x0) = [0 1 0]x0
                 [0 1 1]  ,
     
                 [1 1 1]  
     [top](x0) = [0 0 0]x0
                 [0 0 0]  ,
     
                       [0]
     [free](x0) = x0 + [0]
                       [1]
    orientation:
                    [1 1 1]    [1]    [1 1 1]                      
     top(free(x)) = [0 0 0]x + [0] >= [0 0 0]x = top(check(new(x)))
                    [0 0 0]    [0]    [0 0 0]                      
     
                    [1 0 0]    [0]    [1 0 0]    [0]               
     new(free(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = free(new(x))
                    [0 1 1]    [1]    [0 1 1]    [1]               
     
                    [0]    [0]                
     new(serve()) = [1] >= [1] = free(serve())
                    [1]    [1]                
     
                      [1 0 0]    [0]    [1 0 0]    [0]                 
     check(free(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = free(check(x))
                      [0 0 1]    [1]    [0 0 1]    [1]                 
     
                     [1 0 0]     [1 0 0]                 
     check(new(x)) = [0 0 0]x >= [0 0 0]x = new(check(x))
                     [0 1 1]     [0 0 1]                 
    problem:
     new(free(x)) -> free(new(x))
     new(serve()) -> free(serve())
     check(free(x)) -> free(check(x))
     check(new(x)) -> new(check(x))
    Matrix Interpretation Processor: dim=3
     
     interpretation:
                [0]
      [serve] = [0]
                [1],
      
                    [1 0 0]  
      [check](x0) = [0 1 0]x0
                    [0 0 0]  ,
      
                  [1 1 1]  
      [new](x0) = [1 1 1]x0
                  [0 0 1]  ,
      
                        [0]
      [free](x0) = x0 + [1]
                        [0]
     orientation:
                     [1 1 1]    [1]    [1 1 1]    [0]               
      new(free(x)) = [1 1 1]x + [1] >= [1 1 1]x + [1] = free(new(x))
                     [0 0 1]    [0]    [0 0 1]    [0]               
      
                     [1]    [0]                
      new(serve()) = [1] >= [1] = free(serve())
                     [1]    [1]                
      
                       [1 0 0]    [0]    [1 0 0]    [0]                 
      check(free(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = free(check(x))
                       [0 0 0]    [0]    [0 0 0]    [0]                 
      
                      [1 1 1]     [1 1 0]                 
      check(new(x)) = [1 1 1]x >= [1 1 0]x = new(check(x))
                      [0 0 0]     [0 0 0]                 
     problem:
      check(free(x)) -> free(check(x))
      check(new(x)) -> new(check(x))
     Matrix Interpretation Processor: dim=3
      
      interpretation:
                     [1 1 0]  
       [check](x0) = [0 1 0]x0
                     [0 0 0]  ,
       
                   [1 0 0]     [0]
       [new](x0) = [0 1 0]x0 + [1]
                   [0 0 0]     [0],
       
                    [1 0 0]  
       [free](x0) = [0 1 0]x0
                    [0 0 0]  
      orientation:
                        [1 1 0]     [1 1 0]                  
       check(free(x)) = [0 1 0]x >= [0 1 0]x = free(check(x))
                        [0 0 0]     [0 0 0]                  
       
                       [1 1 0]    [1]    [1 1 0]    [0]                
       check(new(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = new(check(x))
                       [0 0 0]    [0]    [0 0 0]    [0]                
      problem:
       check(free(x)) -> free(check(x))
      Matrix Interpretation Processor: dim=3
       
       interpretation:
                      [1 0 1]  
        [check](x0) = [0 0 0]x0
                      [0 0 1]  ,
        
                     [1 0 0]     [0]
        [free](x0) = [0 0 0]x0 + [0]
                     [0 0 1]     [1]
       orientation:
                         [1 0 1]    [1]    [1 0 1]    [0]                 
        check(free(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = free(check(x))
                         [0 0 1]    [1]    [0 0 1]    [1]                 
       problem:
        
       Qed