WORST_CASE(?,O(n^2))
* Step 1: NaturalMI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            active(c(X)) -> mark(d(X))
            active(f(X)) -> f(active(X))
            active(f(f(X))) -> mark(c(f(g(f(X)))))
            active(h(X)) -> h(active(X))
            active(h(X)) -> mark(c(d(X)))
            c(ok(X)) -> ok(c(X))
            d(ok(X)) -> ok(d(X))
            f(mark(X)) -> mark(f(X))
            f(ok(X)) -> ok(f(X))
            g(ok(X)) -> ok(g(X))
            h(mark(X)) -> mark(h(X))
            h(ok(X)) -> ok(h(X))
            proper(c(X)) -> c(proper(X))
            proper(d(X)) -> d(proper(X))
            proper(f(X)) -> f(proper(X))
            proper(g(X)) -> g(proper(X))
            proper(h(X)) -> h(proper(X))
            top(mark(X)) -> top(proper(X))
            top(ok(X)) -> top(active(X))
        - Signature:
            {active/1,c/1,d/1,f/1,g/1,h/1,proper/1,top/1} / {mark/1,ok/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {active,c,d,f,g,h,proper,top} and constructors {mark,ok}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 2, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(c) = {1},
          uargs(d) = {1},
          uargs(f) = {1},
          uargs(g) = {1},
          uargs(h) = {1},
          uargs(mark) = {1},
          uargs(ok) = {1},
          uargs(top) = {1}
        
        Following symbols are considered usable:
          {active,c,d,f,g,h,proper,top}
        TcT has computed the following interpretation:
          p(active) = [1 5] x1 + [4]
                      [0 1]      [4]
               p(c) = [1 2] x1 + [1]
                      [0 1]      [1]
               p(d) = [1 2] x1 + [0]
                      [0 1]      [2]
               p(f) = [1 1] x1 + [0]
                      [0 1]      [1]
               p(g) = [1 1] x1 + [0]
                      [0 1]      [1]
               p(h) = [1 1] x1 + [0]
                      [0 1]      [1]
            p(mark) = [1 1] x1 + [0]
                      [0 1]      [2]
              p(ok) = [1 5] x1 + [1]
                      [0 1]      [6]
          p(proper) = [1 1] x1 + [0]
                      [0 1]      [0]
             p(top) = [1 2] x1 + [0]
                      [0 0]      [4]
        
        Following rules are strictly oriented:
           active(c(X)) = [1 7] X + [10]     
                          [0 1]     [5]      
                        > [1 3] X + [2]      
                          [0 1]     [4]      
                        = mark(d(X))         
        
           active(f(X)) = [1 6] X + [9]      
                          [0 1]     [5]      
                        > [1 6] X + [8]      
                          [0 1]     [5]      
                        = f(active(X))       
        
        active(f(f(X))) = [1 7] X + [15]     
                          [0 1]     [6]      
                        > [1 6] X + [14]     
                          [0 1]     [6]      
                        = mark(c(f(g(f(X)))))
        
           active(h(X)) = [1 6] X + [9]      
                          [0 1]     [5]      
                        > [1 6] X + [8]      
                          [0 1]     [5]      
                        = h(active(X))       
        
           active(h(X)) = [1 6] X + [9]      
                          [0 1]     [5]      
                        > [1 5] X + [8]      
                          [0 1]     [5]      
                        = mark(c(d(X)))      
        
               c(ok(X)) = [1 7] X + [14]     
                          [0 1]     [7]      
                        > [1 7] X + [7]      
                          [0 1]     [7]      
                        = ok(c(X))           
        
               d(ok(X)) = [1 7] X + [13]     
                          [0 1]     [8]      
                        > [1 7] X + [11]     
                          [0 1]     [8]      
                        = ok(d(X))           
        
             f(mark(X)) = [1 2] X + [2]      
                          [0 1]     [3]      
                        > [1 2] X + [1]      
                          [0 1]     [3]      
                        = mark(f(X))         
        
               f(ok(X)) = [1 6] X + [7]      
                          [0 1]     [7]      
                        > [1 6] X + [6]      
                          [0 1]     [7]      
                        = ok(f(X))           
        
               g(ok(X)) = [1 6] X + [7]      
                          [0 1]     [7]      
                        > [1 6] X + [6]      
                          [0 1]     [7]      
                        = ok(g(X))           
        
             h(mark(X)) = [1 2] X + [2]      
                          [0 1]     [3]      
                        > [1 2] X + [1]      
                          [0 1]     [3]      
                        = mark(h(X))         
        
               h(ok(X)) = [1 6] X + [7]      
                          [0 1]     [7]      
                        > [1 6] X + [6]      
                          [0 1]     [7]      
                        = ok(h(X))           
        
           proper(c(X)) = [1 3] X + [2]      
                          [0 1]     [1]      
                        > [1 3] X + [1]      
                          [0 1]     [1]      
                        = c(proper(X))       
        
           proper(d(X)) = [1 3] X + [2]      
                          [0 1]     [2]      
                        > [1 3] X + [0]      
                          [0 1]     [2]      
                        = d(proper(X))       
        
           proper(f(X)) = [1 2] X + [1]      
                          [0 1]     [1]      
                        > [1 2] X + [0]      
                          [0 1]     [1]      
                        = f(proper(X))       
        
           proper(g(X)) = [1 2] X + [1]      
                          [0 1]     [1]      
                        > [1 2] X + [0]      
                          [0 1]     [1]      
                        = g(proper(X))       
        
           proper(h(X)) = [1 2] X + [1]      
                          [0 1]     [1]      
                        > [1 2] X + [0]      
                          [0 1]     [1]      
                        = h(proper(X))       
        
           top(mark(X)) = [1 3] X + [4]      
                          [0 0]     [4]      
                        > [1 3] X + [0]      
                          [0 0]     [4]      
                        = top(proper(X))     
        
             top(ok(X)) = [1 7] X + [13]     
                          [0 0]     [4]      
                        > [1 7] X + [12]     
                          [0 0]     [4]      
                        = top(active(X))     
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))