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 + [1]
                       [0]
  orientation:
                            [1]        [1]                   
   a(lambda(x),y) = x + y + [1] >= x + [1] = lambda(a(x,1()))
                            [0]        [0]                   
   
                            [1]            [1]                        
   a(lambda(x),y) = x + y + [1] >= x + y + [1] = 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 + [1] >= 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=1
    
    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) = 2x0 + 2x1,
     
     [t] = 0,
     
     [1] = 0,
     
     [a](x0, x1) = x0 + x1,
     
     [lambda](x0) = x0 + 1/2
    orientation:
     a#(lambda(x),y) = 2x + 2y + 1 >= 2x = a#(x,1())
     
     a#(lambda(x),y) = 2x + 2y + 1 >= 2y = a#(y,t())
     
     a#(lambda(x),y) = 2x + 2y + 1 >= 2x + 2y = a#(x,a(y,t()))
     
     a#(a(x,y),z) = 2x + 2y + 2z >= 2y + 2z = a#(y,z)
     
     a#(a(x,y),z) = 2x + 2y + 2z >= 2x + 2y + 2z = a#(x,a(y,z))
     
     a(lambda(x),y) = x + y + 1/2 >= x + 1/2 = lambda(a(x,1()))
     
     a(lambda(x),y) = x + y + 1/2 >= x + y + 1/2 = lambda(a(x,a(y,t())))
     
     a(a(x,y),z) = x + y + z >= x + y + z = a(x,a(y,z))
     
     a(x,y) = x + y >= x = x
     
     a(x,y) = x + y >= y = y
    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
     Subterm Criterion Processor:
      simple projection:
       pi(a#) = 0
      problem:
       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
      Qed