YES

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

Proof:
 Matrix Interpretation Processor: dim=2
  
  interpretation:
             [1 0]     [2]
   [h](x0) = [1 0]x0 + [2],
   
             [1 0]  
   [d](x0) = [0 0]x0,
   
                [1 0]  
   [mark](x0) = [0 0]x0,
   
             [1 0]  
   [c](x0) = [0 0]x0,
   
             [1 0]  
   [g](x0) = [0 0]x0,
   
                  [1 0]  
   [active](x0) = [0 0]x0,
   
             [2 0]  
   [f](x0) = [0 0]x0
  orientation:
                     [4 0]     [4 0]                       
   active(f(f(X))) = [0 0]X >= [0 0]X = mark(c(f(g(f(X)))))
   
                  [1 0]     [1 0]              
   active(c(X)) = [0 0]X >= [0 0]X = mark(d(X))
   
                  [1 0]    [2]    [1 0]                 
   active(h(X)) = [0 0]X + [0] >= [0 0]X = mark(c(d(X)))
   
                [2 0]     [2 0]                      
   mark(f(X)) = [0 0]X >= [0 0]X = active(f(mark(X)))
   
                [1 0]     [1 0]                
   mark(c(X)) = [0 0]X >= [0 0]X = active(c(X))
   
                [1 0]     [1 0]                
   mark(g(X)) = [0 0]X >= [0 0]X = active(g(X))
   
                [1 0]     [1 0]                
   mark(d(X)) = [0 0]X >= [0 0]X = active(d(X))
   
                [1 0]    [2]    [1 0]    [2]                     
   mark(h(X)) = [0 0]X + [0] >= [0 0]X + [0] = active(h(mark(X)))
   
                [2 0]     [2 0]        
   f(mark(X)) = [0 0]X >= [0 0]X = f(X)
   
                  [2 0]     [2 0]        
   f(active(X)) = [0 0]X >= [0 0]X = f(X)
   
                [1 0]     [1 0]        
   c(mark(X)) = [0 0]X >= [0 0]X = c(X)
   
                  [1 0]     [1 0]        
   c(active(X)) = [0 0]X >= [0 0]X = c(X)
   
                [1 0]     [1 0]        
   g(mark(X)) = [0 0]X >= [0 0]X = g(X)
   
                  [1 0]     [1 0]        
   g(active(X)) = [0 0]X >= [0 0]X = g(X)
   
                [1 0]     [1 0]        
   d(mark(X)) = [0 0]X >= [0 0]X = d(X)
   
                  [1 0]     [1 0]        
   d(active(X)) = [0 0]X >= [0 0]X = d(X)
   
                [1 0]    [2]    [1 0]    [2]       
   h(mark(X)) = [1 0]X + [2] >= [1 0]X + [2] = h(X)
   
                  [1 0]    [2]    [1 0]    [2]       
   h(active(X)) = [1 0]X + [2] >= [1 0]X + [2] = h(X)
  problem:
   active(f(f(X))) -> mark(c(f(g(f(X)))))
   active(c(X)) -> mark(d(X))
   mark(f(X)) -> active(f(mark(X)))
   mark(c(X)) -> active(c(X))
   mark(g(X)) -> active(g(X))
   mark(d(X)) -> active(d(X))
   mark(h(X)) -> active(h(mark(X)))
   f(mark(X)) -> f(X)
   f(active(X)) -> f(X)
   c(mark(X)) -> c(X)
   c(active(X)) -> c(X)
   g(mark(X)) -> g(X)
   g(active(X)) -> g(X)
   d(mark(X)) -> d(X)
   d(active(X)) -> d(X)
   h(mark(X)) -> h(X)
   h(active(X)) -> h(X)
  String Reversal Processor:
   f(f(active(X))) -> f(g(f(c(mark(X)))))
   c(active(X)) -> d(mark(X))
   f(mark(X)) -> mark(f(active(X)))
   c(mark(X)) -> c(active(X))
   g(mark(X)) -> g(active(X))
   d(mark(X)) -> d(active(X))
   h(mark(X)) -> mark(h(active(X)))
   mark(f(X)) -> f(X)
   active(f(X)) -> f(X)
   mark(c(X)) -> c(X)
   active(c(X)) -> c(X)
   mark(g(X)) -> g(X)
   active(g(X)) -> g(X)
   mark(d(X)) -> d(X)
   active(d(X)) -> d(X)
   mark(h(X)) -> h(X)
   active(h(X)) -> h(X)
   Matrix Interpretation Processor: dim=3
    
    interpretation:
               [1 0 0]  
     [h](x0) = [0 0 0]x0
               [0 0 0]  ,
     
               [1 0 0]  
     [d](x0) = [0 0 0]x0
               [0 0 0]  ,
     
                  [1 0 1]  
     [mark](x0) = [0 0 0]x0
                  [0 0 1]  ,
     
               [1 0 0]     [0]
     [c](x0) = [0 0 0]x0 + [0]
               [0 0 0]     [1],
     
               [1 0 0]  
     [g](x0) = [0 0 0]x0
               [0 0 0]  ,
     
                    [1 0 1]     [0]
     [active](x0) = [0 0 0]x0 + [0]
                    [0 0 0]     [1],
     
               [1 0 0]  
     [f](x0) = [0 0 0]x0
               [0 0 0]  
    orientation:
                       [1 0 1]     [1 0 1]                       
     f(f(active(X))) = [0 0 0]X >= [0 0 0]X = f(g(f(c(mark(X)))))
                       [0 0 0]     [0 0 0]                       
     
                    [1 0 1]    [0]    [1 0 1]              
     c(active(X)) = [0 0 0]X + [0] >= [0 0 0]X = d(mark(X))
                    [0 0 0]    [1]    [0 0 0]              
     
                  [1 0 1]     [1 0 1]                      
     f(mark(X)) = [0 0 0]X >= [0 0 0]X = mark(f(active(X)))
                  [0 0 0]     [0 0 0]                      
     
                  [1 0 1]    [0]    [1 0 1]    [0]               
     c(mark(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = c(active(X))
                  [0 0 0]    [1]    [0 0 0]    [1]               
     
                  [1 0 1]     [1 0 1]                
     g(mark(X)) = [0 0 0]X >= [0 0 0]X = g(active(X))
                  [0 0 0]     [0 0 0]                
     
                  [1 0 1]     [1 0 1]                
     d(mark(X)) = [0 0 0]X >= [0 0 0]X = d(active(X))
                  [0 0 0]     [0 0 0]                
     
                  [1 0 1]     [1 0 1]                      
     h(mark(X)) = [0 0 0]X >= [0 0 0]X = mark(h(active(X)))
                  [0 0 0]     [0 0 0]                      
     
                  [1 0 0]     [1 0 0]        
     mark(f(X)) = [0 0 0]X >= [0 0 0]X = f(X)
                  [0 0 0]     [0 0 0]        
     
                    [1 0 0]    [0]    [1 0 0]        
     active(f(X)) = [0 0 0]X + [0] >= [0 0 0]X = f(X)
                    [0 0 0]    [1]    [0 0 0]        
     
                  [1 0 0]    [1]    [1 0 0]    [0]       
     mark(c(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = c(X)
                  [0 0 0]    [1]    [0 0 0]    [1]       
     
                    [1 0 0]    [1]    [1 0 0]    [0]       
     active(c(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = c(X)
                    [0 0 0]    [1]    [0 0 0]    [1]       
     
                  [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 + [0] >= [0 0 0]X = g(X)
                    [0 0 0]    [1]    [0 0 0]        
     
                  [1 0 0]     [1 0 0]        
     mark(d(X)) = [0 0 0]X >= [0 0 0]X = d(X)
                  [0 0 0]     [0 0 0]        
     
                    [1 0 0]    [0]    [1 0 0]        
     active(d(X)) = [0 0 0]X + [0] >= [0 0 0]X = d(X)
                    [0 0 0]    [1]    [0 0 0]        
     
                  [1 0 0]     [1 0 0]        
     mark(h(X)) = [0 0 0]X >= [0 0 0]X = h(X)
                  [0 0 0]     [0 0 0]        
     
                    [1 0 0]    [0]    [1 0 0]        
     active(h(X)) = [0 0 0]X + [0] >= [0 0 0]X = h(X)
                    [0 0 0]    [1]    [0 0 0]        
    problem:
     f(f(active(X))) -> f(g(f(c(mark(X)))))
     c(active(X)) -> d(mark(X))
     f(mark(X)) -> mark(f(active(X)))
     c(mark(X)) -> c(active(X))
     g(mark(X)) -> g(active(X))
     d(mark(X)) -> d(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(d(X)) -> d(X)
     active(d(X)) -> d(X)
     mark(h(X)) -> h(X)
     active(h(X)) -> h(X)
    Matrix Interpretation Processor: dim=2
     
     interpretation:
                [2 0]  
      [h](x0) = [0 0]x0,
      
                [1 0]  
      [d](x0) = [0 0]x0,
      
                     
      [mark](x0) = x0,
      
                  
      [c](x0) = x0,
      
                [1 0]  
      [g](x0) = [0 0]x0,
      
                       
      [active](x0) = x0,
      
                [2 1]     [0]
      [f](x0) = [0 0]x0 + [1]
     orientation:
                        [4 2]    [1]    [4 2]    [0]                      
      f(f(active(X))) = [0 0]X + [1] >= [0 0]X + [1] = f(g(f(c(mark(X)))))
      
                          [1 0]              
      c(active(X)) = X >= [0 0]X = d(mark(X))
      
                   [2 1]    [0]    [2 1]    [0]                     
      f(mark(X)) = [0 0]X + [1] >= [0 0]X + [1] = mark(f(active(X)))
      
                                        
      c(mark(X)) = X >= X = c(active(X))
      
                   [1 0]     [1 0]                
      g(mark(X)) = [0 0]X >= [0 0]X = g(active(X))
      
                   [1 0]     [1 0]                
      d(mark(X)) = [0 0]X >= [0 0]X = d(active(X))
      
                   [2 0]     [2 0]                      
      h(mark(X)) = [0 0]X >= [0 0]X = mark(h(active(X)))
      
                   [2 1]    [0]    [2 1]    [0]       
      mark(f(X)) = [0 0]X + [1] >= [0 0]X + [1] = f(X)
      
                     [2 1]    [0]    [2 1]    [0]       
      active(f(X)) = [0 0]X + [1] >= [0 0]X + [1] = f(X)
      
                   [1 0]     [1 0]        
      mark(g(X)) = [0 0]X >= [0 0]X = g(X)
      
                     [1 0]     [1 0]        
      active(g(X)) = [0 0]X >= [0 0]X = g(X)
      
                   [1 0]     [1 0]        
      mark(d(X)) = [0 0]X >= [0 0]X = d(X)
      
                     [1 0]     [1 0]        
      active(d(X)) = [0 0]X >= [0 0]X = d(X)
      
                   [2 0]     [2 0]        
      mark(h(X)) = [0 0]X >= [0 0]X = h(X)
      
                     [2 0]     [2 0]        
      active(h(X)) = [0 0]X >= [0 0]X = h(X)
     problem:
      c(active(X)) -> d(mark(X))
      f(mark(X)) -> mark(f(active(X)))
      c(mark(X)) -> c(active(X))
      g(mark(X)) -> g(active(X))
      d(mark(X)) -> d(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(d(X)) -> d(X)
      active(d(X)) -> d(X)
      mark(h(X)) -> h(X)
      active(h(X)) -> h(X)
     String Reversal Processor:
      active(c(X)) -> mark(d(X))
      mark(f(X)) -> active(f(mark(X)))
      mark(c(X)) -> active(c(X))
      mark(g(X)) -> active(g(X))
      mark(d(X)) -> active(d(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)
      d(mark(X)) -> d(X)
      d(active(X)) -> d(X)
      h(mark(X)) -> h(X)
      h(active(X)) -> h(X)
      WPO Processor:
       algebra: Sum
       weight function:
        w0 = 0
        w(f) = 4
        w(c) = 2
        w(h) = w(d) = w(mark) = w(g) = w(active) = 0
       status function:
        st(h) = st(d) = st(mark) = st(c) = st(g) = st(active) = st(f) = [0]
       precedence:
        mark > h ~ d ~ c ~ g ~ active ~ f
       problem:
        
       Qed