/export/starexec/sandbox/solver/bin/starexec_run_ttt2 /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/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:
              [1 0 0]     [0]
   [up](x0) = [0 0 0]x0 + [1]
              [0 0 0]     [0],
   
                [1 0 0]  
   [sent](x0) = [0 1 0]x0
                [0 0 0]  ,
   
           [0]
   [bot] = [0]
           [0],
   
               [1 0 0]  
   [top](x0) = [1 0 0]x0
               [0 0 0]  ,
   
               [1 0 0]     [0]
   [rec](x0) = [0 0 0]x0 + [1]
               [0 0 0]     [0],
   
                 [1 0 0]  
   [check](x0) = [0 1 0]x0
                 [0 1 0]  ,
   
              [1 0 0]     [1]
   [no](x0) = [0 1 0]x0 + [0]
              [0 1 0]     [0]
  orientation:
                 [1 0 0]    [0]    [1 0 0]    [0]               
   rec(rec(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = sent(rec(x))
                 [0 0 0]    [0]    [0 0 0]    [0]               
   
                  [1 0 0]    [0]    [1 0 0]    [0]               
   rec(sent(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = sent(rec(x))
                  [0 0 0]    [0]    [0 0 0]    [0]               
   
                [1 0 0]    [1]    [1 0 0]    [0]               
   rec(no(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = sent(rec(x))
                [0 0 0]    [0]    [0 0 0]    [0]               
   
                [0]    [0]                  
   rec(bot()) = [1] >= [1] = up(sent(bot()))
                [0]    [0]                  
   
                [1 0 0]    [0]    [1 0 0]    [0]             
   rec(up(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = up(rec(x))
                [0 0 0]    [0]    [0 0 0]    [0]             
   
                 [1 0 0]    [0]    [1 0 0]    [0]              
   sent(up(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = up(sent(x))
                 [0 0 0]    [0]    [0 0 0]    [0]              
   
               [1 0 0]    [1]    [1 0 0]    [1]            
   no(up(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = up(no(x))
               [0 0 0]    [1]    [0 0 0]    [0]            
   
                     [1 0 0]     [1 0 0]                      
   top(rec(up(x))) = [1 0 0]x >= [1 0 0]x = top(check(rec(x)))
                     [0 0 0]     [0 0 0]                      
   
                      [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]    [1]    [1 0 0]                      
   top(no(up(x))) = [1 0 0]x + [1] >= [1 0 0]x = top(check(rec(x)))
                    [0 0 0]    [0]    [0 0 0]                      
   
                  [1 0 0]    [0]    [1 0 0]    [0]               
   check(up(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = up(check(x))
                  [0 0 0]    [1]    [0 0 0]    [0]               
   
                    [1 0 0]     [1 0 0]                  
   check(sent(x)) = [0 1 0]x >= [0 1 0]x = sent(check(x))
                    [0 1 0]     [0 0 0]                  
   
                   [1 0 0]    [0]    [1 0 0]    [0]                
   check(rec(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = rec(check(x))
                   [0 0 0]    [1]    [0 0 0]    [0]                
   
                  [1 0 0]    [1]    [1 0 0]    [1]               
   check(no(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = no(check(x))
                  [0 1 0]    [0]    [0 1 0]    [0]               
   
                  [1 0 0]    [1]    [1 0 0]    [1]        
   check(no(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = no(x)
                  [0 1 0]    [0]    [0 1 0]    [0]        
  problem:
   rec(rec(x)) -> sent(rec(x))
   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(rec(up(x))) -> top(check(rec(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=3
   
   interpretation:
               [1 1 1]     [0]
    [up](x0) = [0 0 0]x0 + [0]
               [0 0 0]     [1],
    
                 [1 0 0]  
    [sent](x0) = [0 0 0]x0
                 [0 0 1]  ,
    
            [0]
    [bot] = [0]
            [0],
    
                [1 0 0]  
    [top](x0) = [0 0 0]x0
                [0 0 0]  ,
    
                [1 0 1]     [0]
    [rec](x0) = [0 0 0]x0 + [0]
                [0 0 0]     [1],
    
                    
    [check](x0) = x0
                    ,
    
               [1 1 0]  
    [no](x0) = [0 0 0]x0
               [0 0 1]  
   orientation:
                  [1 0 1]    [1]    [1 0 1]    [0]               
    rec(rec(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = sent(rec(x))
                  [0 0 0]    [1]    [0 0 0]    [1]               
    
                   [1 0 1]    [0]    [1 0 1]    [0]               
    rec(sent(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = sent(rec(x))
                   [0 0 0]    [1]    [0 0 0]    [1]               
    
                 [0]    [0]                  
    rec(bot()) = [0] >= [0] = up(sent(bot()))
                 [1]    [1]                  
    
                 [1 1 1]    [1]    [1 0 1]    [1]             
    rec(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(rec(x))
                 [0 0 0]    [1]    [0 0 0]    [1]             
    
                  [1 1 1]    [0]    [1 0 1]    [0]              
    sent(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(sent(x))
                  [0 0 0]    [1]    [0 0 0]    [1]              
    
                [1 1 1]    [0]    [1 1 1]    [0]            
    no(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(no(x))
                [0 0 0]    [1]    [0 0 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 1 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 1 1]    [0]    [1 1 1]    [0]               
    check(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(check(x))
                   [0 0 0]    [1]    [0 0 0]    [1]               
    
                     [1 0 0]     [1 0 0]                  
    check(sent(x)) = [0 0 0]x >= [0 0 0]x = sent(check(x))
                     [0 0 1]     [0 0 1]                  
    
                    [1 0 1]    [0]    [1 0 1]    [0]                
    check(rec(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = rec(check(x))
                    [0 0 0]    [1]    [0 0 0]    [1]                
    
                   [1 1 0]     [1 1 0]                
    check(no(x)) = [0 0 0]x >= [0 0 0]x = no(check(x))
                   [0 0 1]     [0 0 1]                
    
                   [1 1 0]     [1 1 0]         
    check(no(x)) = [0 0 0]x >= [0 0 0]x = no(x)
                   [0 0 1]     [0 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))
    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:
     [up](x0) = x0,
     
     [sent](x0) = 4x0,
     
     [bot] = 0,
     
     [top](x0) = 4x0,
     
     [rec](x0) = x0,
     
     [check](x0) = 4x0,
     
     [no](x0) = 4x0 + 2
    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)) = 4x + 2 >= 4x + 2 = up(no(x))
     
     top(sent(up(x))) = 16x >= 16x = 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)) = 16x + 8 >= 16x + 2 = no(check(x))
     
     check(no(x)) = 16x + 8 >= 4x + 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=1
     
     interpretation:
      [up](x0) = 4x0 + 1,
      
      [sent](x0) = x0,
      
      [bot] = 4,
      
      [top](x0) = 4x0,
      
      [rec](x0) = 4x0 + 1,
      
      [check](x0) = x0,
      
      [no](x0) = 2x0
     orientation:
      rec(sent(x)) = 4x + 1 >= 4x + 1 = sent(rec(x))
      
      rec(bot()) = 17 >= 17 = up(sent(bot()))
      
      rec(up(x)) = 16x + 5 >= 16x + 5 = up(rec(x))
      
      sent(up(x)) = 4x + 1 >= 4x + 1 = up(sent(x))
      
      no(up(x)) = 8x + 2 >= 8x + 1 = up(no(x))
      
      top(sent(up(x))) = 16x + 4 >= 16x + 4 = top(check(rec(x)))
      
      check(up(x)) = 4x + 1 >= 4x + 1 = up(check(x))
      
      check(sent(x)) = x >= x = sent(check(x))
      
      check(rec(x)) = 4x + 1 >= 4x + 1 = rec(check(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))
      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:
                       [0]
       [up](x0) = x0 + [1]
                       [0],
       
                      
       [sent](x0) = x0
                      ,
       
               [0]
       [bot] = [0]
               [1],
       
                   [1 1 1]  
       [top](x0) = [0 0 1]x0
                   [0 1 1]  ,
       
                   [1 0 0]  
       [rec](x0) = [0 1 1]x0
                   [0 0 1]  ,
       
                     [1 0 0]  
       [check](x0) = [0 1 0]x0
                     [0 0 0]  
      orientation:
                      [1 0 0]     [1 0 0]                
       rec(sent(x)) = [0 1 1]x >= [0 1 1]x = sent(rec(x))
                      [0 0 1]     [0 0 1]                
       
                    [0]    [0]                  
       rec(bot()) = [1] >= [1] = up(sent(bot()))
                    [1]    [1]                  
       
                    [1 0 0]    [0]    [1 0 0]    [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]             
       
                         [0]        [0]              
       sent(up(x)) = x + [1] >= x + [1] = up(sent(x))
                         [0]        [0]              
       
                          [1 1 1]    [1]    [1 1 1]                      
       top(sent(up(x))) = [0 0 1]x + [0] >= [0 0 0]x = top(check(rec(x)))
                          [0 1 1]    [1]    [0 1 1]                      
       
                      [1 0 0]    [0]    [1 0 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]               
       
                        [1 0 0]     [1 0 0]                  
       check(sent(x)) = [0 1 0]x >= [0 1 0]x = sent(check(x))
                        [0 0 0]     [0 0 0]                  
       
                       [1 0 0]     [1 0 0]                 
       check(rec(x)) = [0 1 1]x >= [0 1 0]x = rec(check(x))
                       [0 0 0]     [0 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:
                   [1 0 0]  
        [up](x0) = [0 1 0]x0
                   [0 0 0]  ,
        
                     [1 0 0]     [0]
        [sent](x0) = [0 1 0]x0 + [1]
                     [0 0 0]     [1],
        
                [1]
        [bot] = [0]
                [0],
        
                    [1 1 0]     [0]
        [rec](x0) = [1 1 0]x0 + [0]
                    [0 0 0]     [1],
        
                        
        [check](x0) = x0
                        
       orientation:
                       [1 1 0]    [1]    [1 1 0]    [0]               
        rec(sent(x)) = [1 1 0]x + [1] >= [1 1 0]x + [1] = sent(rec(x))
                       [0 0 0]    [1]    [0 0 0]    [1]               
        
                     [1]    [1]                  
        rec(bot()) = [1] >= [1] = up(sent(bot()))
                     [1]    [0]                  
        
                     [1 1 0]    [0]    [1 1 0]              
        rec(up(x)) = [1 1 0]x + [0] >= [1 1 0]x = up(rec(x))
                     [0 0 0]    [1]    [0 0 0]              
        
                      [1 0 0]    [0]    [1 0 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]    [0]              
        
                       [1 0 0]     [1 0 0]                
        check(up(x)) = [0 1 0]x >= [0 1 0]x = up(check(x))
                       [0 0 0]     [0 0 0]                
        
                         [1 0 0]    [0]    [1 0 0]    [0]                 
        check(sent(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = sent(check(x))
                         [0 0 0]    [1]    [0 0 0]    [1]                 
        
                        [1 1 0]    [0]    [1 1 0]    [0]                
        check(rec(x)) = [1 1 0]x + [0] >= [1 1 0]x + [0] = rec(check(x))
                        [0 0 0]    [1]    [0 0 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:
         [up](x0) = x0,
         
         [sent](x0) = x0 + 1,
         
         [bot] = 1,
         
         [rec](x0) = 3x0,
         
         [check](x0) = x0
        orientation:
         rec(bot()) = 3 >= 2 = up(sent(bot()))
         
         rec(up(x)) = 3x >= 3x = up(rec(x))
         
         sent(up(x)) = x + 1 >= x + 1 = up(sent(x))
         
         check(up(x)) = x >= x = up(check(x))
         
         check(sent(x)) = x + 1 >= x + 1 = sent(check(x))
         
         check(rec(x)) = 3x >= 3x = rec(check(x))
        problem:
         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:
                     [1 0 0]     [1]
          [up](x0) = [0 0 0]x0 + [0]
                     [0 1 1]     [0],
          
                       [1 0 0]     [0]
          [sent](x0) = [0 0 0]x0 + [0]
                       [0 0 1]     [1],
          
                        
          [rec](x0) = x0
                        ,
          
                        [1 0 1]     [0]
          [check](x0) = [0 0 0]x0 + [1]
                        [1 0 1]     [0]
         orientation:
                       [1 0 0]    [1]    [1 0 0]    [1]             
          rec(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(rec(x))
                       [0 1 1]    [0]    [0 1 1]    [0]             
          
                        [1 0 0]    [1]    [1 0 0]    [1]              
          sent(up(x)) = [0 0 0]x + [0] >= [0 0 0]x + [0] = up(sent(x))
                        [0 1 1]    [1]    [0 0 1]    [1]              
          
                         [1 1 1]    [1]    [1 0 1]    [1]               
          check(up(x)) = [0 0 0]x + [1] >= [0 0 0]x + [0] = up(check(x))
                         [1 1 1]    [1]    [1 0 1]    [1]               
          
                           [1 0 1]    [1]    [1 0 1]    [0]                 
          check(sent(x)) = [0 0 0]x + [1] >= [0 0 0]x + [0] = sent(check(x))
                           [1 0 1]    [1]    [1 0 1]    [1]                 
          
                          [1 0 1]    [0]    [1 0 1]    [0]                
          check(rec(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = rec(check(x))
                          [1 0 1]    [0]    [1 0 1]    [0]                
         problem:
          rec(up(x)) -> up(rec(x))
          sent(up(x)) -> up(sent(x))
          check(up(x)) -> up(check(x))
          check(rec(x)) -> rec(check(x))
         Matrix Interpretation Processor: dim=1
          
          interpretation:
           [up](x0) = x0,
           
           [sent](x0) = x0 + 6,
           
           [rec](x0) = x0 + 1,
           
           [check](x0) = 2x0 + 3
          orientation:
           rec(up(x)) = x + 1 >= x + 1 = up(rec(x))
           
           sent(up(x)) = x + 6 >= x + 6 = up(sent(x))
           
           check(up(x)) = 2x + 3 >= 2x + 3 = up(check(x))
           
           check(rec(x)) = 2x + 5 >= 2x + 4 = rec(check(x))
          problem:
           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 0 0]     [0]
            [up](x0) = [0 0 1]x0 + [0]
                       [0 0 1]     [1],
            
                         [1 0 1]  
            [sent](x0) = [0 1 0]x0
                         [0 0 1]  ,
            
                        [1 0 1]  
            [rec](x0) = [0 1 0]x0
                        [0 0 1]  ,
            
                          [1 0 1]  
            [check](x0) = [0 1 0]x0
                          [0 0 1]  
           orientation:
                         [1 0 1]    [1]    [1 0 1]    [0]             
            rec(up(x)) = [0 0 1]x + [0] >= [0 0 1]x + [0] = up(rec(x))
                         [0 0 1]    [1]    [0 0 1]    [1]             
            
                          [1 0 1]    [1]    [1 0 1]    [0]              
            sent(up(x)) = [0 0 1]x + [0] >= [0 0 1]x + [0] = up(sent(x))
                          [0 0 1]    [1]    [0 0 1]    [1]              
            
                           [1 0 1]    [1]    [1 0 1]    [0]               
            check(up(x)) = [0 0 1]x + [0] >= [0 0 1]x + [0] = up(check(x))
                           [0 0 1]    [1]    [0 0 1]    [1]               
           problem:
            
           Qed