YES

Problem:
 top(sent(x)) -> top(check(rest(x)))
 rest(nil()) -> sent(nil())
 rest(cons(x,y)) -> sent(y)
 check(sent(x)) -> sent(check(x))
 check(rest(x)) -> rest(check(x))
 check(cons(x,y)) -> cons(check(x),y)
 check(cons(x,y)) -> cons(x,check(y))
 check(cons(x,y)) -> cons(x,y)

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [nil] = 0,
   
   [top](x0) = 4x0 + 2,
   
   [check](x0) = x0,
   
   [cons](x0, x1) = x0 + 2x1 + 2,
   
   [sent](x0) = 2x0 + 4,
   
   [rest](x0) = 2x0 + 4
  orientation:
   top(sent(x)) = 8x + 18 >= 8x + 18 = top(check(rest(x)))
   
   rest(nil()) = 4 >= 4 = sent(nil())
   
   rest(cons(x,y)) = 2x + 4y + 8 >= 2y + 4 = sent(y)
   
   check(sent(x)) = 2x + 4 >= 2x + 4 = sent(check(x))
   
   check(rest(x)) = 2x + 4 >= 2x + 4 = rest(check(x))
   
   check(cons(x,y)) = x + 2y + 2 >= x + 2y + 2 = cons(check(x),y)
   
   check(cons(x,y)) = x + 2y + 2 >= x + 2y + 2 = cons(x,check(y))
   
   check(cons(x,y)) = x + 2y + 2 >= x + 2y + 2 = cons(x,y)
  problem:
   top(sent(x)) -> top(check(rest(x)))
   rest(nil()) -> sent(nil())
   check(sent(x)) -> sent(check(x))
   check(rest(x)) -> rest(check(x))
   check(cons(x,y)) -> cons(check(x),y)
   check(cons(x,y)) -> cons(x,check(y))
   check(cons(x,y)) -> cons(x,y)
  Matrix Interpretation Processor: dim=3
   
   interpretation:
            [0]
    [nil] = [1]
            [1],
    
                [1 1 1]  
    [top](x0) = [0 0 0]x0
                [0 0 0]  ,
    
                  [1 0 0]  
    [check](x0) = [0 1 0]x0
                  [0 0 0]  ,
    
                     [1 1 0]     [1 1 0]  
    [cons](x0, x1) = [0 1 0]x0 + [0 0 1]x1
                     [0 0 0]     [0 0 0]  ,
    
                 [1 1 0]     [0]
    [sent](x0) = [0 0 0]x0 + [1]
                 [0 0 1]     [0],
    
                 [1 1 0]  
    [rest](x0) = [0 0 1]x0
                 [0 0 1]  
   orientation:
                   [1 1 1]    [1]    [1 1 1]                       
    top(sent(x)) = [0 0 0]x + [0] >= [0 0 0]x = top(check(rest(x)))
                   [0 0 0]    [0]    [0 0 0]                       
    
                  [1]    [1]              
    rest(nil()) = [1] >= [1] = sent(nil())
                  [1]    [1]              
    
                     [1 1 0]    [0]    [1 1 0]    [0]                 
    check(sent(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = sent(check(x))
                     [0 0 0]    [0]    [0 0 0]    [0]                 
    
                     [1 1 0]     [1 1 0]                  
    check(rest(x)) = [0 0 1]x >= [0 0 0]x = rest(check(x))
                     [0 0 0]     [0 0 0]                  
    
                       [1 1 0]    [1 1 0]     [1 1 0]    [1 1 0]                    
    check(cons(x,y)) = [0 1 0]x + [0 0 1]y >= [0 1 0]x + [0 0 1]y = cons(check(x),y)
                       [0 0 0]    [0 0 0]     [0 0 0]    [0 0 0]                    
    
                       [1 1 0]    [1 1 0]     [1 1 0]    [1 1 0]                    
    check(cons(x,y)) = [0 1 0]x + [0 0 1]y >= [0 1 0]x + [0 0 0]y = cons(x,check(y))
                       [0 0 0]    [0 0 0]     [0 0 0]    [0 0 0]                    
    
                       [1 1 0]    [1 1 0]     [1 1 0]    [1 1 0]             
    check(cons(x,y)) = [0 1 0]x + [0 0 1]y >= [0 1 0]x + [0 0 1]y = cons(x,y)
                       [0 0 0]    [0 0 0]     [0 0 0]    [0 0 0]             
   problem:
    rest(nil()) -> sent(nil())
    check(sent(x)) -> sent(check(x))
    check(rest(x)) -> rest(check(x))
    check(cons(x,y)) -> cons(check(x),y)
    check(cons(x,y)) -> cons(x,check(y))
    check(cons(x,y)) -> cons(x,y)
   Matrix Interpretation Processor: dim=1
    
    interpretation:
     [nil] = 6,
     
     [check](x0) = 5x0 + 4,
     
     [cons](x0, x1) = 3x0 + 2x1 + 2,
     
     [sent](x0) = 3x0 + 2,
     
     [rest](x0) = 3x0 + 2
    orientation:
     rest(nil()) = 20 >= 20 = sent(nil())
     
     check(sent(x)) = 15x + 14 >= 15x + 14 = sent(check(x))
     
     check(rest(x)) = 15x + 14 >= 15x + 14 = rest(check(x))
     
     check(cons(x,y)) = 15x + 10y + 14 >= 15x + 2y + 14 = cons(check(x),y)
     
     check(cons(x,y)) = 15x + 10y + 14 >= 3x + 10y + 10 = cons(x,check(y))
     
     check(cons(x,y)) = 15x + 10y + 14 >= 3x + 2y + 2 = cons(x,y)
    problem:
     rest(nil()) -> sent(nil())
     check(sent(x)) -> sent(check(x))
     check(rest(x)) -> rest(check(x))
     check(cons(x,y)) -> cons(check(x),y)
    Matrix Interpretation Processor: dim=1
     
     interpretation:
      [nil] = 0,
      
      [check](x0) = 4x0 + 3,
      
      [cons](x0, x1) = 4x0 + 2x1 + 4,
      
      [sent](x0) = 3x0 + 2,
      
      [rest](x0) = 3x0 + 2
     orientation:
      rest(nil()) = 2 >= 2 = sent(nil())
      
      check(sent(x)) = 12x + 11 >= 12x + 11 = sent(check(x))
      
      check(rest(x)) = 12x + 11 >= 12x + 11 = rest(check(x))
      
      check(cons(x,y)) = 16x + 8y + 19 >= 16x + 2y + 16 = cons(check(x),y)
     problem:
      rest(nil()) -> sent(nil())
      check(sent(x)) -> sent(check(x))
      check(rest(x)) -> rest(check(x))
     Matrix Interpretation Processor: dim=3
      
      interpretation:
               [0]
       [nil] = [1]
               [1],
       
                     [1 0 1]     [0]
       [check](x0) = [0 0 0]x0 + [1]
                     [0 1 0]     [0],
       
                      
       [sent](x0) = x0
                      ,
       
                    [1 0 1]     [0]
       [rest](x0) = [0 0 0]x0 + [1]
                    [0 1 0]     [0]
      orientation:
                     [1]    [0]              
       rest(nil()) = [1] >= [1] = sent(nil())
                     [1]    [1]              
       
                        [1 0 1]    [0]    [1 0 1]    [0]                 
       check(sent(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = sent(check(x))
                        [0 1 0]    [0]    [0 1 0]    [0]                 
       
                        [1 1 1]    [0]    [1 1 1]    [0]                 
       check(rest(x)) = [0 0 0]x + [1] >= [0 0 0]x + [1] = rest(check(x))
                        [0 0 0]    [1]    [0 0 0]    [1]                 
      problem:
       check(sent(x)) -> sent(check(x))
       check(rest(x)) -> rest(check(x))
      Matrix Interpretation Processor: dim=3
       
       interpretation:
                      [1 0 1]  
        [check](x0) = [0 1 0]x0
                      [0 1 0]  ,
        
                     [1 0 1]     [0]
        [sent](x0) = [0 1 0]x0 + [1]
                     [0 1 0]     [1],
        
                     [1 0 1]     [1]
        [rest](x0) = [0 1 0]x0 + [0]
                     [0 1 0]     [0]
       orientation:
                         [1 1 1]    [1]    [1 1 1]    [0]                 
        check(sent(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = sent(check(x))
                         [0 1 0]    [1]    [0 1 0]    [1]                 
        
                         [1 1 1]    [1]    [1 1 1]    [1]                 
        check(rest(x)) = [0 1 0]x + [0] >= [0 1 0]x + [0] = rest(check(x))
                         [0 1 0]    [0]    [0 1 0]    [0]                 
       problem:
        check(rest(x)) -> rest(check(x))
       Matrix Interpretation Processor: dim=3
        
        interpretation:
                       [1 1 0]  
         [check](x0) = [0 1 0]x0
                       [0 0 0]  ,
         
                      [1 0 0]     [0]
         [rest](x0) = [0 1 0]x0 + [1]
                      [0 0 0]     [0]
        orientation:
                          [1 1 0]    [1]    [1 1 0]    [0]                 
         check(rest(x)) = [0 1 0]x + [1] >= [0 1 0]x + [1] = rest(check(x))
                          [0 0 0]    [0]    [0 0 0]    [0]                 
        problem:
         
        Qed