YES

Problem:
 strict:
  app(nil(),k) -> k
  app(l,nil()) -> l
  app(cons(x,l),k) -> cons(x,app(l,k))
  sum(cons(x,nil())) -> cons(x,nil())
  sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
  sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
  plus(0(),y) -> y
  plus(s(x),y) -> s(plus(x,y))
 weak:
  cons(x,cons(y,l)) -> cons(y,cons(x,l))

Proof:
 Matrix Interpretation Processor: dim=2
  
  interpretation:
                         [1 0]  
   [plus](x0, x1) = x0 + [0 2]x1,
   
                   [1 1]          [1]
   [app](x0, x1) = [0 1]x0 + x1 + [0],
   
               [1 0]  
   [sum](x0) = [2 0]x0,
   
         [2]
   [0] = [0],
   
           [0]
   [nil] = [0],
   
                  [2]
   [s](x0) = x0 + [2],
   
                    [1 0]       
   [cons](x0, x1) = [2 0]x0 + x1
  orientation:
                      [1]         
   app(nil(),k) = k + [0] >= k = k
   
                  [1 1]    [1]         
   app(l,nil()) = [0 1]l + [0] >= l = l
   
                          [1 1]    [3 0]    [1]        [1 1]    [1 0]    [1]                   
   app(cons(x,l),k) = k + [0 1]l + [2 0]x + [0] >= k + [0 1]l + [2 0]x + [0] = cons(x,app(l,k))
   
                        [1 0]     [1 0]                 
   sum(cons(x,nil())) = [2 0]x >= [2 0]x = cons(x,nil())
   
                            [1 0]    [1 0]    [1 0]     [1 0]    [1 0]    [1 0]                          
   sum(cons(x,cons(y,l))) = [2 0]l + [2 0]x + [2 0]y >= [2 0]l + [2 0]x + [2 0]y = sum(cons(plus(x,y),l))
   
                                   [1 0]    [1 1]    [1 0]    [1 0]    [1]    [1 0]    [1 1]    [1 0]    [1 0]    [1]                                     
   sum(app(l,cons(x,cons(y,k)))) = [2 0]k + [2 2]l + [2 0]x + [2 0]y + [2] >= [2 0]k + [2 2]l + [2 0]x + [2 0]y + [2] = sum(app(l,sum(cons(x,cons(y,k)))))
   
                 [1 0]    [2]         
   plus(0(),y) = [0 2]y + [0] >= y = y
   
                      [1 0]    [2]        [1 0]    [2]               
   plus(s(x),y) = x + [0 2]y + [2] >= x + [0 2]y + [2] = s(plus(x,y))
   
                           [1 0]    [1 0]         [1 0]    [1 0]                     
   cons(x,cons(y,l)) = l + [2 0]x + [2 0]y >= l + [2 0]x + [2 0]y = cons(y,cons(x,l))
  problem:
   strict:
    app(cons(x,l),k) -> cons(x,app(l,k))
    sum(cons(x,nil())) -> cons(x,nil())
    sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
    sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
    plus(s(x),y) -> s(plus(x,y))
   weak:
    cons(x,cons(y,l)) -> cons(y,cons(x,l))
  Matrix Interpretation Processor: dim=2
   
   interpretation:
                     [1 0]     [1 0]  
    [plus](x0, x1) = [0 0]x0 + [1 0]x1,
    
                         [1 0]  
    [app](x0, x1) = x0 + [0 0]x1,
    
                [1 0]     [0]
    [sum](x0) = [0 0]x0 + [2],
    
            [0]
    [nil] = [0],
    
              [1 0]  
    [s](x0) = [0 0]x0,
    
                     [1 0]     [1 1]     [0]
    [cons](x0, x1) = [0 0]x0 + [0 0]x1 + [2]
   orientation:
                       [1 0]    [1 1]    [1 0]    [0]    [1 0]    [1 1]    [1 0]    [0]                   
    app(cons(x,l),k) = [0 0]k + [0 0]l + [0 0]x + [2] >= [0 0]k + [0 0]l + [0 0]x + [2] = cons(x,app(l,k))
    
                         [1 0]    [0]    [1 0]    [0]                
    sum(cons(x,nil())) = [0 0]x + [2] >= [0 0]x + [2] = cons(x,nil())
    
                             [1 1]    [1 0]    [1 0]    [2]    [1 1]    [1 0]    [1 0]    [0]                         
    sum(cons(x,cons(y,l))) = [0 0]l + [0 0]x + [0 0]y + [2] >= [0 0]l + [0 0]x + [0 0]y + [2] = sum(cons(plus(x,y),l))
    
                                    [1 1]    [1 0]    [1 0]    [1 0]    [2]    [1 1]    [1 0]    [1 0]    [1 0]    [2]                                     
    sum(app(l,cons(x,cons(y,k)))) = [0 0]k + [0 0]l + [0 0]x + [0 0]y + [2] >= [0 0]k + [0 0]l + [0 0]x + [0 0]y + [2] = sum(app(l,sum(cons(x,cons(y,k)))))
    
                   [1 0]    [1 0]     [1 0]    [1 0]                
    plus(s(x),y) = [0 0]x + [1 0]y >= [0 0]x + [0 0]y = s(plus(x,y))
    
                        [1 1]    [1 0]    [1 0]    [2]    [1 1]    [1 0]    [1 0]    [2]                    
    cons(x,cons(y,l)) = [0 0]l + [0 0]x + [0 0]y + [2] >= [0 0]l + [0 0]x + [0 0]y + [2] = cons(y,cons(x,l))
   problem:
    strict:
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),y) -> s(plus(x,y))
    weak:
     cons(x,cons(y,l)) -> cons(y,cons(x,l))
   Bounds Processor:
    bound: 1
    enrichment: match-rt
    automaton:
     final states: {7}
     transitions:
      app1(7,18) -> 19*
      sum1(19) -> 7*
      sum1(17) -> 18*
      cons0(7,7) -> 7*
      app0(7,7) -> 7*
      cons1(7,19) -> 19*
      cons1(7,16) -> 16,17
      cons1(7,7) -> 16*
      s0(7) -> 7*
      sum0(7) -> 7*
      plus0(7,7) -> 7*
      nil0() -> 7*
    problem:
     strict:
      app(cons(x,l),k) -> cons(x,app(l,k))
      sum(cons(x,nil())) -> cons(x,nil())
      plus(s(x),y) -> s(plus(x,y))
     weak:
      cons(x,cons(y,l)) -> cons(y,cons(x,l))
    Bounds Processor:
     bound: 1
     enrichment: match-rt
     automaton:
      final states: {7}
      transitions:
       app1(11,7) -> 11*
       app1(7,7) -> 7*
       cons0(7,7) -> 7*
       app0(7,7) -> 7*
       cons1(7,7) -> 7*
       cons1(7,11) -> 7*
       s0(7) -> 7*
       sum0(7) -> 7*
       plus0(7,7) -> 7*
       nil0() -> 7*
       nil1() -> 11*
     problem:
      strict:
       app(cons(x,l),k) -> cons(x,app(l,k))
       plus(s(x),y) -> s(plus(x,y))
      weak:
       cons(x,cons(y,l)) -> cons(y,cons(x,l))
     Matrix Interpretation Processor: dim=2
      
      interpretation:
                        [1 2]     [2 0]  
       [plus](x0, x1) = [1 0]x0 + [3 0]x1,
       
                       [1 0]     [1 2]     [2]
       [app](x0, x1) = [2 0]x0 + [0 2]x1 + [0],
       
                      [1]
       [s](x0) = x0 + [1],
       
                        [1 0]     [1 0]  
       [cons](x0, x1) = [0 0]x0 + [0 0]x1
      orientation:
                          [1 2]    [1 0]    [1 0]    [2]    [1 2]    [1 0]    [1 0]    [2]                   
       app(cons(x,l),k) = [0 2]k + [2 0]l + [2 0]x + [0] >= [0 0]k + [0 0]l + [0 0]x + [0] = cons(x,app(l,k))
       
                      [1 2]    [2 0]    [3]    [1 2]    [2 0]    [1]               
       plus(s(x),y) = [1 0]x + [3 0]y + [1] >= [1 0]x + [3 0]y + [1] = s(plus(x,y))
       
                           [1 0]    [1 0]    [1 0]     [1 0]    [1 0]    [1 0]                     
       cons(x,cons(y,l)) = [0 0]l + [0 0]x + [0 0]y >= [0 0]l + [0 0]x + [0 0]y = cons(y,cons(x,l))
      problem:
       strict:
        app(cons(x,l),k) -> cons(x,app(l,k))
       weak:
        cons(x,cons(y,l)) -> cons(y,cons(x,l))
      Matrix Interpretation Processor: dim=2
       
       interpretation:
                        [1 1]     [2 1]     [2]
        [app](x0, x1) = [0 2]x0 + [0 2]x1 + [0],
        
                         [1 0]          [0]
        [cons](x0, x1) = [1 0]x0 + x1 + [1]
       orientation:
                           [2 1]    [1 1]    [2 0]    [3]    [2 1]    [1 1]    [1 0]    [2]                   
        app(cons(x,l),k) = [0 2]k + [0 2]l + [2 0]x + [2] >= [0 2]k + [0 2]l + [1 0]x + [1] = cons(x,app(l,k))
        
                                [1 0]    [1 0]    [0]        [1 0]    [1 0]    [0]                    
        cons(x,cons(y,l)) = l + [1 0]x + [1 0]y + [2] >= l + [1 0]x + [1 0]y + [2] = cons(y,cons(x,l))
       problem:
        strict:
         
        weak:
         cons(x,cons(y,l)) -> cons(y,cons(x,l))
       Qed