/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:
 zeros() -> cons(0(),n__zeros())
 tail(cons(X,XS)) -> activate(XS)
 zeros() -> n__zeros()
 activate(n__zeros()) -> zeros()
 activate(X) -> X

Proof:
 Matrix Interpretation Processor: dim=3
  
  interpretation:
                    [1 0 1]  
   [activate](x0) = [0 1 0]x0
                    [0 0 1]  ,
   
                [1 0 1]     [1]
   [tail](x0) = [0 1 0]x0 + [0]
                [0 0 1]     [0],
   
                    [1 1 0]       
   [cons](x0, x1) = [0 0 0]x0 + x1
                    [0 0 0]       ,
   
                [0]
   [n__zeros] = [0]
                [1],
   
         [0]
   [0] = [0]
         [0],
   
             [1]
   [zeros] = [0]
             [1]
  orientation:
             [1]    [0]                       
   zeros() = [0] >= [0] = cons(0(),n__zeros())
             [1]    [1]                       
   
                      [1 1 0]    [1 0 1]     [1]    [1 0 1]                 
   tail(cons(X,XS)) = [0 0 0]X + [0 1 0]XS + [0] >= [0 1 0]XS = activate(XS)
                      [0 0 0]    [0 0 1]     [0]    [0 0 1]                 
   
             [1]    [0]             
   zeros() = [0] >= [0] = n__zeros()
             [1]    [1]             
   
                          [1]    [1]          
   activate(n__zeros()) = [0] >= [0] = zeros()
                          [1]    [1]          
   
                 [1 0 1]          
   activate(X) = [0 1 0]X >= X = X
                 [0 0 1]          
  problem:
   activate(n__zeros()) -> zeros()
   activate(X) -> X
  Matrix Interpretation Processor: dim=3
   
   interpretation:
                       
    [activate](x0) = x0
                       ,
    
                 [1]
    [n__zeros] = [1]
                 [0],
    
              [0]
    [zeros] = [1]
              [0]
   orientation:
                           [1]    [0]          
    activate(n__zeros()) = [1] >= [1] = zeros()
                           [0]    [0]          
    
                            
    activate(X) = X >= X = X
                            
   problem:
    activate(X) -> X
   Matrix Interpretation Processor: dim=3
    
    interpretation:
                           [1]
     [activate](x0) = x0 + [0]
                           [0]
    orientation:
                       [1]         
     activate(X) = X + [0] >= X = X
                       [0]         
    problem:
     
    Qed