YES

Problem:
 active(f(X)) -> mark(g(h(f(X))))
 mark(f(X)) -> active(f(mark(X)))
 mark(g(X)) -> active(g(X))
 mark(h(X)) -> active(h(mark(X)))
 f(mark(X)) -> f(X)
 f(active(X)) -> f(X)
 g(mark(X)) -> g(X)
 g(active(X)) -> g(X)
 h(mark(X)) -> h(X)
 h(active(X)) -> h(X)

Proof:
 String Reversal Processor:
  f(active(X)) -> f(h(g(mark(X))))
  f(mark(X)) -> mark(f(active(X)))
  g(mark(X)) -> g(active(X))
  h(mark(X)) -> mark(h(active(X)))
  mark(f(X)) -> f(X)
  active(f(X)) -> f(X)
  mark(g(X)) -> g(X)
  active(g(X)) -> g(X)
  mark(h(X)) -> h(X)
  active(h(X)) -> h(X)
  Matrix Interpretation Processor: dim=3
   
   interpretation:
                 [1 1 0]     [0]
    [mark](x0) = [0 0 1]x0 + [0]
                 [1 1 0]     [1],
    
              [1 0 0]  
    [g](x0) = [0 0 0]x0
              [0 0 0]  ,
    
              [1 0 0]  
    [h](x0) = [0 0 1]x0
              [0 0 1]  ,
    
                   [1 0 0]  
    [active](x0) = [0 1 0]x0
                   [0 1 0]  ,
    
              [1 0 1]  
    [f](x0) = [1 0 1]x0
              [1 0 1]  
   orientation:
                   [1 1 0]     [1 1 0]                    
    f(active(X)) = [1 1 0]X >= [1 1 0]X = f(h(g(mark(X))))
                   [1 1 0]     [1 1 0]                    
    
                 [2 2 0]    [1]    [2 2 0]    [0]                     
    f(mark(X)) = [2 2 0]X + [1] >= [1 1 0]X + [0] = mark(f(active(X)))
                 [2 2 0]    [1]    [2 2 0]    [1]                     
    
                 [1 1 0]     [1 0 0]                
    g(mark(X)) = [0 0 0]X >= [0 0 0]X = g(active(X))
                 [0 0 0]     [0 0 0]                
    
                 [1 1 0]    [0]    [1 1 0]    [0]                     
    h(mark(X)) = [1 1 0]X + [1] >= [0 1 0]X + [0] = mark(h(active(X)))
                 [1 1 0]    [1]    [1 1 0]    [1]                     
    
                 [2 0 2]    [0]    [1 0 1]        
    mark(f(X)) = [1 0 1]X + [0] >= [1 0 1]X = f(X)
                 [2 0 2]    [1]    [1 0 1]        
    
                   [1 0 1]     [1 0 1]        
    active(f(X)) = [1 0 1]X >= [1 0 1]X = f(X)
                   [1 0 1]     [1 0 1]        
    
                 [1 0 0]    [0]    [1 0 0]        
    mark(g(X)) = [0 0 0]X + [0] >= [0 0 0]X = g(X)
                 [1 0 0]    [1]    [0 0 0]        
    
                   [1 0 0]     [1 0 0]        
    active(g(X)) = [0 0 0]X >= [0 0 0]X = g(X)
                   [0 0 0]     [0 0 0]        
    
                 [1 0 1]    [0]    [1 0 0]        
    mark(h(X)) = [0 0 1]X + [0] >= [0 0 1]X = h(X)
                 [1 0 1]    [1]    [0 0 1]        
    
                   [1 0 0]     [1 0 0]        
    active(h(X)) = [0 0 1]X >= [0 0 1]X = h(X)
                   [0 0 1]     [0 0 1]        
   problem:
    f(active(X)) -> f(h(g(mark(X))))
    g(mark(X)) -> g(active(X))
    h(mark(X)) -> mark(h(active(X)))
    mark(f(X)) -> f(X)
    active(f(X)) -> f(X)
    mark(g(X)) -> g(X)
    active(g(X)) -> g(X)
    mark(h(X)) -> h(X)
    active(h(X)) -> h(X)
   Matrix Interpretation Processor: dim=3
    
    interpretation:
                  [1 0 0]  
     [mark](x0) = [0 0 0]x0
                  [0 1 0]  ,
     
               [1 0 0]  
     [g](x0) = [0 0 0]x0
               [0 0 0]  ,
     
               [1 0 1]  
     [h](x0) = [0 0 0]x0
               [0 0 0]  ,
     
                    [1 0 0]     [0]
     [active](x0) = [0 0 0]x0 + [1]
                    [0 0 0]     [0],
     
               [1 1 0]  
     [f](x0) = [0 0 0]x0
               [0 0 0]  
    orientation:
                    [1 0 0]    [1]    [1 0 0]                    
     f(active(X)) = [0 0 0]X + [0] >= [0 0 0]X = f(h(g(mark(X))))
                    [0 0 0]    [0]    [0 0 0]                    
     
                  [1 0 0]     [1 0 0]                
     g(mark(X)) = [0 0 0]X >= [0 0 0]X = g(active(X))
                  [0 0 0]     [0 0 0]                
     
                  [1 1 0]     [1 0 0]                      
     h(mark(X)) = [0 0 0]X >= [0 0 0]X = mark(h(active(X)))
                  [0 0 0]     [0 0 0]                      
     
                  [1 1 0]     [1 1 0]        
     mark(f(X)) = [0 0 0]X >= [0 0 0]X = f(X)
                  [0 0 0]     [0 0 0]        
     
                    [1 1 0]    [0]    [1 1 0]        
     active(f(X)) = [0 0 0]X + [1] >= [0 0 0]X = f(X)
                    [0 0 0]    [0]    [0 0 0]        
     
                  [1 0 0]     [1 0 0]        
     mark(g(X)) = [0 0 0]X >= [0 0 0]X = g(X)
                  [0 0 0]     [0 0 0]        
     
                    [1 0 0]    [0]    [1 0 0]        
     active(g(X)) = [0 0 0]X + [1] >= [0 0 0]X = g(X)
                    [0 0 0]    [0]    [0 0 0]        
     
                  [1 0 1]     [1 0 1]        
     mark(h(X)) = [0 0 0]X >= [0 0 0]X = h(X)
                  [0 0 0]     [0 0 0]        
     
                    [1 0 1]    [0]    [1 0 1]        
     active(h(X)) = [0 0 0]X + [1] >= [0 0 0]X = h(X)
                    [0 0 0]    [0]    [0 0 0]        
    problem:
     g(mark(X)) -> g(active(X))
     h(mark(X)) -> mark(h(active(X)))
     mark(f(X)) -> f(X)
     active(f(X)) -> f(X)
     mark(g(X)) -> g(X)
     active(g(X)) -> g(X)
     mark(h(X)) -> h(X)
     active(h(X)) -> h(X)
    Arctic Interpretation Processor:
     dimension: 1
     interpretation:
      [mark](x0) = 2x0,
      
      [g](x0) = 14x0,
      
      [h](x0) = x0,
      
      [active](x0) = x0,
      
      [f](x0) = 8x0
     orientation:
      g(mark(X)) = 16X >= 14X = g(active(X))
      
      h(mark(X)) = 2X >= 2X = mark(h(active(X)))
      
      mark(f(X)) = 10X >= 8X = f(X)
      
      active(f(X)) = 8X >= 8X = f(X)
      
      mark(g(X)) = 16X >= 14X = g(X)
      
      active(g(X)) = 14X >= 14X = g(X)
      
      mark(h(X)) = 2X >= X = h(X)
      
      active(h(X)) = X >= X = h(X)
     problem:
      h(mark(X)) -> mark(h(active(X)))
      active(f(X)) -> f(X)
      active(g(X)) -> g(X)
      active(h(X)) -> h(X)
     KBO Processor:
      weight function:
       w0 = 1
       w(mark) = w(g) = w(h) = w(f) = 1
       w(active) = 0
      precedence:
       active > h > mark ~ g ~ f
      problem:
       
      Qed