/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:
 a(lambda(x),y) -> lambda(a(x,1()))
 a(lambda(x),y) -> lambda(a(x,a(y,t())))
 a(a(x,y),z) -> a(x,a(y,z))
 lambda(x) -> x
 a(x,y) -> x
 a(x,y) -> y

Proof:
 Matrix Interpretation Processor: dim=3
  
  interpretation:
         [0]
   [t] = [0]
         [0],
   
         [0]
   [1] = [0]
         [0],
   
                        
   [a](x0, x1) = x0 + x1
                        ,
   
                       [1]
   [lambda](x0) = x0 + [0]
                       [0]
  orientation:
                            [1]        [1]                   
   a(lambda(x),y) = x + y + [0] >= x + [0] = lambda(a(x,1()))
                            [0]        [0]                   
   
                            [1]            [1]                        
   a(lambda(x),y) = x + y + [0] >= x + y + [0] = lambda(a(x,a(y,t())))
                            [0]            [0]                        
   
                                                     
   a(a(x,y),z) = x + y + z >= x + y + z = a(x,a(y,z))
                                                     
   
                   [1]         
   lambda(x) = x + [0] >= x = x
                   [0]         
   
                          
   a(x,y) = x + y >= x = x
                          
   
                          
   a(x,y) = x + y >= y = y
                          
  problem:
   a(lambda(x),y) -> lambda(a(x,1()))
   a(lambda(x),y) -> lambda(a(x,a(y,t())))
   a(a(x,y),z) -> a(x,a(y,z))
   a(x,y) -> x
   a(x,y) -> y
  DP Processor:
   DPs:
    a#(lambda(x),y) -> a#(x,1())
    a#(lambda(x),y) -> a#(y,t())
    a#(lambda(x),y) -> a#(x,a(y,t()))
    a#(a(x,y),z) -> a#(y,z)
    a#(a(x,y),z) -> a#(x,a(y,z))
   TRS:
    a(lambda(x),y) -> lambda(a(x,1()))
    a(lambda(x),y) -> lambda(a(x,a(y,t())))
    a(a(x,y),z) -> a(x,a(y,z))
    a(x,y) -> x
    a(x,y) -> y
   Matrix Interpretation Processor: dim=3
    
    usable rules:
     a(lambda(x),y) -> lambda(a(x,1()))
     a(lambda(x),y) -> lambda(a(x,a(y,t())))
     a(a(x,y),z) -> a(x,a(y,z))
     a(x,y) -> x
     a(x,y) -> y
    interpretation:
     [a#](x0, x1) = [0 1 0]x0 + [0 1 0]x1,
     
           [1]
     [t] = [0]
           [0],
     
           [0]
     [1] = [0]
           [0],
     
                             [1]
     [a](x0, x1) = x0 + x1 + [0]
                             [0],
     
                    [0 0 0]     [0]
     [lambda](x0) = [0 1 0]x0 + [1]
                    [0 0 0]     [0]
    orientation:
     a#(lambda(x),y) = [0 1 0]x + [0 1 0]y + [1] >= [0 1 0]x = a#(x,1())
     
     a#(lambda(x),y) = [0 1 0]x + [0 1 0]y + [1] >= [0 1 0]y = a#(y,t())
     
     a#(lambda(x),y) = [0 1 0]x + [0 1 0]y + [1] >= [0 1 0]x + [0 1 0]y = a#(x,a(y,t()))
     
     a#(a(x,y),z) = [0 1 0]x + [0 1 0]y + [0 1 0]z >= [0 1 0]y + [0 1 0]z = a#(y,z)
     
     a#(a(x,y),z) = [0 1 0]x + [0 1 0]y + [0 1 0]z >= [0 1 0]x + [0 1 0]y + [0 1 0]z = a#(x,a(y,z))
     
                      [0 0 0]        [1]    [0 0 0]    [0]                   
     a(lambda(x),y) = [0 1 0]x + y + [1] >= [0 1 0]x + [1] = lambda(a(x,1()))
                      [0 0 0]        [0]    [0 0 0]    [0]                   
     
                      [0 0 0]        [1]    [0 0 0]    [0 0 0]    [0]                        
     a(lambda(x),y) = [0 1 0]x + y + [1] >= [0 1 0]x + [0 1 0]y + [1] = lambda(a(x,a(y,t())))
                      [0 0 0]        [0]    [0 0 0]    [0 0 0]    [0]                        
     
                               [2]                [2]              
     a(a(x,y),z) = x + y + z + [0] >= x + y + z + [0] = a(x,a(y,z))
                               [0]                [0]              
     
                      [1]         
     a(x,y) = x + y + [0] >= x = x
                      [0]         
     
                      [1]         
     a(x,y) = x + y + [0] >= y = y
                      [0]         
    problem:
     DPs:
      a#(a(x,y),z) -> a#(y,z)
      a#(a(x,y),z) -> a#(x,a(y,z))
     TRS:
      a(lambda(x),y) -> lambda(a(x,1()))
      a(lambda(x),y) -> lambda(a(x,a(y,t())))
      a(a(x,y),z) -> a(x,a(y,z))
      a(x,y) -> x
      a(x,y) -> y
    Restore Modifier:
     DPs:
      a#(a(x,y),z) -> a#(y,z)
      a#(a(x,y),z) -> a#(x,a(y,z))
     TRS:
      a(lambda(x),y) -> lambda(a(x,1()))
      a(lambda(x),y) -> lambda(a(x,a(y,t())))
      a(a(x,y),z) -> a(x,a(y,z))
      a(x,y) -> x
      a(x,y) -> y
     Size-Change Termination Processor:
      DPs:
       
      TRS:
       a(lambda(x),y) -> lambda(a(x,1()))
       a(lambda(x),y) -> lambda(a(x,a(y,t())))
       a(a(x,y),z) -> a(x,a(y,z))
       a(x,y) -> x
       a(x,y) -> y
      The DP: a#(a(x,y),z) -> a#(y,z) has the edges:
        0 >   0
        1 >=  1
      The DP: a#(a(x,y),z) -> a#(x,a(y,z)) has the edges:
        0 >   0
      Qed