YES

Problem:
 fst(0(),Z) -> nil()
 fst(s(),cons(Y)) -> cons(Y)
 from(X) -> cons(X)
 add(0(),X) -> X
 add(s(),Y) -> s()
 len(nil()) -> 0()
 len(cons(X)) -> s()

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [cons](x0) = x0 + 4,
   
   [fst](x0, x1) = x0 + 4x1,
   
   [s] = 4,
   
   [from](x0) = x0 + 4,
   
   [0] = 7,
   
   [len](x0) = 3x0 + 1,
   
   [add](x0, x1) = x0 + 4x1,
   
   [nil] = 2
  orientation:
   fst(0(),Z) = 4Z + 7 >= 2 = nil()
   
   fst(s(),cons(Y)) = 4Y + 20 >= Y + 4 = cons(Y)
   
   from(X) = X + 4 >= X + 4 = cons(X)
   
   add(0(),X) = 4X + 7 >= X = X
   
   add(s(),Y) = 4Y + 4 >= 4 = s()
   
   len(nil()) = 7 >= 7 = 0()
   
   len(cons(X)) = 3X + 13 >= 4 = s()
  problem:
   from(X) -> cons(X)
   add(s(),Y) -> s()
   len(nil()) -> 0()
  Matrix Interpretation Processor: dim=3
   
   interpretation:
                 [1 0 0]  
    [cons](x0) = [0 0 0]x0
                 [0 0 0]  ,
    
          [0]
    [s] = [1]
          [0],
    
                 [1 0 0]  
    [from](x0) = [0 0 0]x0
                 [0 0 0]  ,
    
          [0]
    [0] = [0]
          [0],
    
                [1 0 0]     [1]
    [len](x0) = [0 0 0]x0 + [0]
                [0 0 0]     [0],
    
                    [1 1 0]     [1 0 0]     [0]
    [add](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [1]
                    [0 0 0]     [0 0 0]     [0],
    
            [0]
    [nil] = [0]
            [0]
   orientation:
              [1 0 0]     [1 0 0]           
    from(X) = [0 0 0]X >= [0 0 0]X = cons(X)
              [0 0 0]     [0 0 0]           
    
                 [1 0 0]    [1]    [0]      
    add(s(),Y) = [0 0 0]Y + [1] >= [1] = s()
                 [0 0 0]    [0]    [0]      
    
                 [1]    [0]      
    len(nil()) = [0] >= [0] = 0()
                 [0]    [0]      
   problem:
    from(X) -> cons(X)
   Matrix Interpretation Processor: dim=3
    
    interpretation:
                  [1 0 0]  
     [cons](x0) = [0 0 0]x0
                  [0 0 0]  ,
     
                  [1 0 0]     [1]
     [from](x0) = [0 0 0]x0 + [0]
                  [0 0 1]     [0]
    orientation:
               [1 0 0]    [1]    [1 0 0]           
     from(X) = [0 0 0]X + [0] >= [0 0 0]X = cons(X)
               [0 0 1]    [0]    [0 0 0]           
    problem:
     
    Qed