/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:
 rec(rec(x)) -> sent(rec(x))
 rec(sent(x)) -> sent(rec(x))
 rec(no(x)) -> sent(rec(x))
 rec(bot()) -> up(sent(bot()))
 rec(up(x)) -> up(rec(x))
 sent(up(x)) -> up(sent(x))
 no(up(x)) -> up(no(x))
 top(rec(up(x))) -> top(check(rec(x)))
 top(sent(up(x))) -> top(check(rec(x)))
 top(no(up(x))) -> top(check(rec(x)))
 check(up(x)) -> up(check(x))
 check(sent(x)) -> sent(check(x))
 check(rec(x)) -> rec(check(x))
 check(no(x)) -> no(check(x))
 check(no(x)) -> no(x)

Proof:
 Matrix Interpretation Processor: dim=3
  
  interpretation:
                   
   [check](x0) = x0
                   ,
   
               [1 0 0]  
   [top](x0) = [0 0 0]x0
               [0 0 0]  ,
   
              [1 0 1]     [0]
   [up](x0) = [0 1 0]x0 + [0]
              [0 1 0]     [1],
   
           [0]
   [bot] = [0]
           [0],
   
                   [1]
   [no](x0) = x0 + [0]
                   [0],
   
                  
   [sent](x0) = x0
                  ,
   
               [1 0 1]     [0]
   [rec](x0) = [0 1 0]x0 + [0]
               [0 1 0]     [1]
  orientation:
                 [1 1 1]    [1]    [1 0 1]    [0]               
   rec(rec(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = sent(rec(x))
                 [0 1 0]    [1]    [0 1 0]    [1]               
   
                  [1 0 1]    [0]    [1 0 1]    [0]               
   rec(sent(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = sent(rec(x))
                  [0 1 0]    [1]    [0 1 0]    [1]               
   
                [1 0 1]    [1]    [1 0 1]    [0]               
   rec(no(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = sent(rec(x))
                [0 1 0]    [1]    [0 1 0]    [1]               
   
                [0]    [0]                  
   rec(bot()) = [0] >= [0] = up(sent(bot()))
                [1]    [1]                  
   
                [1 1 1]    [1]    [1 1 1]    [1]             
   rec(up(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = up(rec(x))
                [0 1 0]    [1]    [0 1 0]    [1]             
   
                 [1 0 1]    [0]    [1 0 1]    [0]              
   sent(up(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = up(sent(x))
                 [0 1 0]    [1]    [0 1 0]    [1]              
   
               [1 0 1]    [1]    [1 0 1]    [1]            
   no(up(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = up(no(x))
               [0 1 0]    [1]    [0 1 0]    [1]            
   
                     [1 1 1]    [1]    [1 0 1]                      
   top(rec(up(x))) = [0 0 0]x + [0] >= [0 0 0]x = top(check(rec(x)))
                     [0 0 0]    [0]    [0 0 0]                      
   
                      [1 0 1]     [1 0 1]                      
   top(sent(up(x))) = [0 0 0]x >= [0 0 0]x = top(check(rec(x)))
                      [0 0 0]     [0 0 0]                      
   
                    [1 0 1]    [1]    [1 0 1]                      
   top(no(up(x))) = [0 0 0]x + [0] >= [0 0 0]x = top(check(rec(x)))
                    [0 0 0]    [0]    [0 0 0]                      
   
                  [1 0 1]    [0]    [1 0 1]    [0]               
   check(up(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = up(check(x))
                  [0 1 0]    [1]    [0 1 0]    [1]               
   
                                           
   check(sent(x)) = x >= x = sent(check(x))
                                           
   
                   [1 0 1]    [0]    [1 0 1]    [0]                
   check(rec(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = rec(check(x))
                   [0 1 0]    [1]    [0 1 0]    [1]                
   
                      [1]        [1]               
   check(no(x)) = x + [0] >= x + [0] = no(check(x))
                      [0]        [0]               
   
                      [1]        [1]        
   check(no(x)) = x + [0] >= x + [0] = no(x)
                      [0]        [0]        
  problem:
   rec(sent(x)) -> sent(rec(x))
   rec(bot()) -> up(sent(bot()))
   rec(up(x)) -> up(rec(x))
   sent(up(x)) -> up(sent(x))
   no(up(x)) -> up(no(x))
   top(sent(up(x))) -> top(check(rec(x)))
   check(up(x)) -> up(check(x))
   check(sent(x)) -> sent(check(x))
   check(rec(x)) -> rec(check(x))
   check(no(x)) -> no(check(x))
   check(no(x)) -> no(x)
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [check](x0) = 4x0,
    
    [top](x0) = x0 + 4,
    
    [up](x0) = x0,
    
    [bot] = 0,
    
    [no](x0) = x0 + 2,
    
    [sent](x0) = 4x0,
    
    [rec](x0) = x0
   orientation:
    rec(sent(x)) = 4x >= 4x = sent(rec(x))
    
    rec(bot()) = 0 >= 0 = up(sent(bot()))
    
    rec(up(x)) = x >= x = up(rec(x))
    
    sent(up(x)) = 4x >= 4x = up(sent(x))
    
    no(up(x)) = x + 2 >= x + 2 = up(no(x))
    
    top(sent(up(x))) = 4x + 4 >= 4x + 4 = top(check(rec(x)))
    
    check(up(x)) = 4x >= 4x = up(check(x))
    
    check(sent(x)) = 16x >= 16x = sent(check(x))
    
    check(rec(x)) = 4x >= 4x = rec(check(x))
    
    check(no(x)) = 4x + 8 >= 4x + 2 = no(check(x))
    
    check(no(x)) = 4x + 8 >= x + 2 = no(x)
   problem:
    rec(sent(x)) -> sent(rec(x))
    rec(bot()) -> up(sent(bot()))
    rec(up(x)) -> up(rec(x))
    sent(up(x)) -> up(sent(x))
    no(up(x)) -> up(no(x))
    top(sent(up(x))) -> top(check(rec(x)))
    check(up(x)) -> up(check(x))
    check(sent(x)) -> sent(check(x))
    check(rec(x)) -> rec(check(x))
   Matrix Interpretation Processor: dim=3
    
    interpretation:
                   [1 0 0]  
     [check](x0) = [0 0 1]x0
                   [0 1 0]  ,
     
                 [1 0 0]  
     [top](x0) = [1 0 0]x0
                 [0 0 0]  ,
     
                     [0]
     [up](x0) = x0 + [1]
                     [1],
     
             [1]
     [bot] = [0]
             [0],
     
                [1 0 1]  
     [no](x0) = [0 0 1]x0
                [1 1 0]  ,
     
                    
     [sent](x0) = x0
                    ,
     
                 [1 0 0]  
     [rec](x0) = [1 0 1]x0
                 [1 1 0]  
    orientation:
                    [1 0 0]     [1 0 0]                
     rec(sent(x)) = [1 0 1]x >= [1 0 1]x = sent(rec(x))
                    [1 1 0]     [1 1 0]                
     
                  [1]    [1]                  
     rec(bot()) = [1] >= [1] = up(sent(bot()))
                  [1]    [1]                  
     
                  [1 0 0]    [0]    [1 0 0]    [0]             
     rec(up(x)) = [1 0 1]x + [1] >= [1 0 1]x + [1] = up(rec(x))
                  [1 1 0]    [1]    [1 1 0]    [1]             
     
                       [0]        [0]              
     sent(up(x)) = x + [1] >= x + [1] = up(sent(x))
                       [1]        [1]              
     
                 [1 0 1]    [1]    [1 0 1]    [0]            
     no(up(x)) = [0 0 1]x + [1] >= [0 0 1]x + [1] = up(no(x))
                 [1 1 0]    [1]    [1 1 0]    [1]            
     
                        [1 0 0]     [1 0 0]                      
     top(sent(up(x))) = [1 0 0]x >= [1 0 0]x = top(check(rec(x)))
                        [0 0 0]     [0 0 0]                      
     
                    [1 0 0]    [0]    [1 0 0]    [0]               
     check(up(x)) = [0 0 1]x + [1] >= [0 0 1]x + [1] = up(check(x))
                    [0 1 0]    [1]    [0 1 0]    [1]               
     
                      [1 0 0]     [1 0 0]                  
     check(sent(x)) = [0 0 1]x >= [0 0 1]x = sent(check(x))
                      [0 1 0]     [0 1 0]                  
     
                     [1 0 0]     [1 0 0]                 
     check(rec(x)) = [1 1 0]x >= [1 1 0]x = rec(check(x))
                     [1 0 1]     [1 0 1]                 
    problem:
     rec(sent(x)) -> sent(rec(x))
     rec(bot()) -> up(sent(bot()))
     rec(up(x)) -> up(rec(x))
     sent(up(x)) -> up(sent(x))
     top(sent(up(x))) -> top(check(rec(x)))
     check(up(x)) -> up(check(x))
     check(sent(x)) -> sent(check(x))
     check(rec(x)) -> rec(check(x))
    Matrix Interpretation Processor: dim=3
     
     interpretation:
                    [1 0 0]  
      [check](x0) = [0 0 0]x0
                    [1 0 0]  ,
      
                  [1 1 0]  
      [top](x0) = [0 0 0]x0
                  [0 0 0]  ,
      
                 [1 0 0]     [1]
      [up](x0) = [0 1 0]x0 + [0]
                 [0 0 0]     [0],
      
              [0]
      [bot] = [1]
              [0],
      
                     
      [sent](x0) = x0
                     ,
      
                  [1 1 0]  
      [rec](x0) = [0 1 0]x0
                  [1 0 0]  
     orientation:
                     [1 1 0]     [1 1 0]                
      rec(sent(x)) = [0 1 0]x >= [0 1 0]x = sent(rec(x))
                     [1 0 0]     [1 0 0]                
      
                   [1]    [1]                  
      rec(bot()) = [1] >= [1] = up(sent(bot()))
                   [0]    [0]                  
      
                   [1 1 0]    [1]    [1 1 0]    [1]             
      rec(up(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = up(rec(x))
                   [1 0 0]    [1]    [0 0 0]    [0]             
      
                    [1 0 0]    [1]    [1 0 0]    [1]              
      sent(up(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = up(sent(x))
                    [0 0 0]    [0]    [0 0 0]    [0]              
      
                         [1 1 0]    [1]    [1 1 0]                      
      top(sent(up(x))) = [0 0 0]x + [0] >= [0 0 0]x = top(check(rec(x)))
                         [0 0 0]    [0]    [0 0 0]                      
      
                     [1 0 0]    [1]    [1 0 0]    [1]               
      check(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(check(x))
                     [1 0 0]    [1]    [0 0 0]    [0]               
      
                       [1 0 0]     [1 0 0]                  
      check(sent(x)) = [0 0 0]x >= [0 0 0]x = sent(check(x))
                       [1 0 0]     [1 0 0]                  
      
                      [1 1 0]     [1 0 0]                 
      check(rec(x)) = [0 0 0]x >= [0 0 0]x = rec(check(x))
                      [1 1 0]     [1 0 0]                 
     problem:
      rec(sent(x)) -> sent(rec(x))
      rec(bot()) -> up(sent(bot()))
      rec(up(x)) -> up(rec(x))
      sent(up(x)) -> up(sent(x))
      check(up(x)) -> up(check(x))
      check(sent(x)) -> sent(check(x))
      check(rec(x)) -> rec(check(x))
     Matrix Interpretation Processor: dim=3
      
      interpretation:
                       
       [check](x0) = x0
                       ,
       
                  [1 0 0]  
       [up](x0) = [0 0 0]x0
                  [0 0 1]  ,
       
               [1]
       [bot] = [1]
               [0],
       
                         [0]
       [sent](x0) = x0 + [0]
                         [1],
       
                   [1 0 1]  
       [rec](x0) = [1 0 0]x0
                   [1 0 1]  
      orientation:
                      [1 0 1]    [1]    [1 0 1]    [0]               
       rec(sent(x)) = [1 0 0]x + [0] >= [1 0 0]x + [0] = sent(rec(x))
                      [1 0 1]    [1]    [1 0 1]    [1]               
       
                    [1]    [1]                  
       rec(bot()) = [1] >= [0] = up(sent(bot()))
                    [1]    [1]                  
       
                    [1 0 1]     [1 0 1]              
       rec(up(x)) = [1 0 0]x >= [0 0 0]x = up(rec(x))
                    [1 0 1]     [1 0 1]              
       
                     [1 0 0]    [0]    [1 0 0]    [0]              
       sent(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(sent(x))
                     [0 0 1]    [1]    [0 0 1]    [1]              
       
                      [1 0 0]     [1 0 0]                
       check(up(x)) = [0 0 0]x >= [0 0 0]x = up(check(x))
                      [0 0 1]     [0 0 1]                
       
                            [0]        [0]                 
       check(sent(x)) = x + [0] >= x + [0] = sent(check(x))
                            [1]        [1]                 
       
                       [1 0 1]     [1 0 1]                 
       check(rec(x)) = [1 0 0]x >= [1 0 0]x = rec(check(x))
                       [1 0 1]     [1 0 1]                 
      problem:
       rec(bot()) -> up(sent(bot()))
       rec(up(x)) -> up(rec(x))
       sent(up(x)) -> up(sent(x))
       check(up(x)) -> up(check(x))
       check(sent(x)) -> sent(check(x))
       check(rec(x)) -> rec(check(x))
      Matrix Interpretation Processor: dim=1
       
       interpretation:
        [check](x0) = 4x0 + 3,
        
        [up](x0) = x0,
        
        [bot] = 0,
        
        [sent](x0) = 3x0 + 2,
        
        [rec](x0) = 2x0 + 2
       orientation:
        rec(bot()) = 2 >= 2 = up(sent(bot()))
        
        rec(up(x)) = 2x + 2 >= 2x + 2 = up(rec(x))
        
        sent(up(x)) = 3x + 2 >= 3x + 2 = up(sent(x))
        
        check(up(x)) = 4x + 3 >= 4x + 3 = up(check(x))
        
        check(sent(x)) = 12x + 11 >= 12x + 11 = sent(check(x))
        
        check(rec(x)) = 8x + 11 >= 8x + 8 = rec(check(x))
       problem:
        rec(bot()) -> up(sent(bot()))
        rec(up(x)) -> up(rec(x))
        sent(up(x)) -> up(sent(x))
        check(up(x)) -> up(check(x))
        check(sent(x)) -> sent(check(x))
       Matrix Interpretation Processor: dim=1
        
        interpretation:
         [check](x0) = 3x0 + 1,
         
         [up](x0) = x0,
         
         [bot] = 0,
         
         [sent](x0) = 4x0 + 4,
         
         [rec](x0) = 4x0 + 4
        orientation:
         rec(bot()) = 4 >= 4 = up(sent(bot()))
         
         rec(up(x)) = 4x + 4 >= 4x + 4 = up(rec(x))
         
         sent(up(x)) = 4x + 4 >= 4x + 4 = up(sent(x))
         
         check(up(x)) = 3x + 1 >= 3x + 1 = up(check(x))
         
         check(sent(x)) = 12x + 13 >= 12x + 8 = sent(check(x))
        problem:
         rec(bot()) -> up(sent(bot()))
         rec(up(x)) -> up(rec(x))
         sent(up(x)) -> up(sent(x))
         check(up(x)) -> up(check(x))
        Matrix Interpretation Processor: dim=3
         
         interpretation:
                        [1 1 0]  
          [check](x0) = [0 1 0]x0
                        [0 0 0]  ,
          
                          [0]
          [up](x0) = x0 + [1]
                          [0],
          
                  [0]
          [bot] = [0]
                  [1],
          
                       [1 1 0]     [0]
          [sent](x0) = [0 1 0]x0 + [0]
                       [0 0 0]     [1],
          
                      [1 1 1]  
          [rec](x0) = [0 1 1]x0
                      [0 0 1]  
         orientation:
                       [1]    [0]                  
          rec(bot()) = [1] >= [1] = up(sent(bot()))
                       [1]    [1]                  
          
                       [1 1 1]    [1]    [1 1 1]    [0]             
          rec(up(x)) = [0 1 1]x + [1] >= [0 1 1]x + [1] = up(rec(x))
                       [0 0 1]    [0]    [0 0 1]    [0]             
          
                        [1 1 0]    [1]    [1 1 0]    [0]              
          sent(up(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = up(sent(x))
                        [0 0 0]    [1]    [0 0 0]    [1]              
          
                         [1 1 0]    [1]    [1 1 0]    [0]               
          check(up(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = up(check(x))
                         [0 0 0]    [0]    [0 0 0]    [0]               
         problem:
          
         Qed