WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            f(a()) -> g(h(a()))
            h(g(x)) -> g(h(f(x)))
            k(x,h(x),a()) -> h(x)
            k(f(x),y,x) -> f(x)
        - Signature:
            {f/1,h/1,k/3} / {a/0,g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {f,h,k} and constructors {a,g}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation (containing no more than 1 non-zero interpretation-entries in the diagonal of the component-wise maxima):
        The following argument positions are considered usable:
          uargs(g) = {1},
          uargs(h) = {1}
        
        Following symbols are considered usable:
          {f,h,k}
        TcT has computed the following interpretation:
          p(a) = [0]                                 
                 [4]                                 
          p(f) = [0 1] x1 + [0]                      
                 [0 0]      [0]                      
          p(g) = [1 1] x1 + [1]                      
                 [0 0]      [0]                      
          p(h) = [4 0] x1 + [0]                      
                 [0 0]      [2]                      
          p(k) = [4 4] x1 + [0 2] x2 + [0 0] x3 + [2]
                 [5 6]      [1 1]      [7 2]      [4]
        
        Following rules are strictly oriented:
               f(a()) = [4]                    
                        [0]                    
                      > [3]                    
                        [0]                    
                      = g(h(a()))              
        
              h(g(x)) = [4 4] x + [4]          
                        [0 0]     [2]          
                      > [0 4] x + [3]          
                        [0 0]     [0]          
                      = g(h(f(x)))             
        
        k(x,h(x),a()) = [4 4] x + [6]          
                        [9 6]     [14]         
                      > [4 0] x + [0]          
                        [0 0]     [2]          
                      = h(x)                   
        
          k(f(x),y,x) = [0 4] x + [0 2] y + [2]
                        [7 7]     [1 1]     [4]
                      > [0 1] x + [0]          
                        [0 0]     [0]          
                      = f(x)                   
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))