WORST_CASE(?,O(n^3))
* Step 1: MI WORST_CASE(?,O(n^3))
    + Considered Problem:
        - Strict TRS:
            active(c()) -> mark(d())
            active(g(X)) -> mark(h(X))
            active(h(d())) -> mark(g(c()))
            g(ok(X)) -> ok(g(X))
            h(ok(X)) -> ok(h(X))
            proper(c()) -> ok(c())
            proper(d()) -> ok(d())
            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,g/1,h/1,proper/1,top/1} / {c/0,d/0,mark/1,ok/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {active,g,h,proper,top} and constructors {c,d,mark,ok}
    + Applied Processor:
        MI {miKind = Automaton Nothing, miDimension = 3, miUArgs = NoUArgs, miURules = NoURules, miSelector = Nothing}
    + Details:
        We apply a matrix interpretation of kind Automaton Nothing:
        
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
          p(active) = [1 0 1]       [0]
                      [1 1 0] x_1 + [0]
                      [1 0 0]       [1]
               p(c) = [0]              
                      [7]              
                      [1]              
               p(d) = [0]              
                      [1]              
                      [5]              
               p(g) = [2 0 0]       [0]
                      [0 0 5] x_1 + [4]
                      [0 0 2]       [3]
               p(h) = [2 0 0]       [0]
                      [0 0 3] x_1 + [0]
                      [0 0 2]       [3]
            p(mark) = [1 0 0]       [0]
                      [1 1 1] x_1 + [1]
                      [1 0 0]       [1]
              p(ok) = [1 0 0]       [2]
                      [1 1 0] x_1 + [0]
                      [1 0 1]       [0]
          p(proper) = [4 0 1]       [2]
                      [0 1 0] x_1 + [0]
                      [0 0 1]       [0]
             p(top) = [2 4 2]       [0]
                      [2 5 3] x_1 + [4]
                      [1 4 2]       [0]
        
        Following rules are strictly oriented:
           active(c()) = [1]              
                         [7]              
                         [1]              
                       > [0]              
                         [7]              
                         [1]              
                       = mark(d())        
        
          active(g(X)) = [2 0 2]     [3]  
                         [2 0 5] X + [4]  
                         [2 0 0]     [1]  
                       > [2 0 0]     [0]  
                         [2 0 5] X + [4]  
                         [2 0 0]     [1]  
                       = mark(h(X))       
        
        active(h(d())) = [13]             
                         [15]             
                         [1]              
                       > [0]              
                         [15]             
                         [1]              
                       = mark(g(c()))     
        
              g(ok(X)) = [2 0 0]     [4]  
                         [5 0 5] X + [4]  
                         [2 0 2]     [3]  
                       > [2 0 0]     [2]  
                         [2 0 5] X + [4]  
                         [2 0 2]     [3]  
                       = ok(g(X))         
        
              h(ok(X)) = [2 0 0]     [4]  
                         [3 0 3] X + [0]  
                         [2 0 2]     [3]  
                       > [2 0 0]     [2]  
                         [2 0 3] X + [0]  
                         [2 0 2]     [3]  
                       = ok(h(X))         
        
           proper(c()) = [3]              
                         [7]              
                         [1]              
                       > [2]              
                         [7]              
                         [1]              
                       = ok(c())          
        
           proper(d()) = [7]              
                         [1]              
                         [5]              
                       > [2]              
                         [1]              
                         [5]              
                       = ok(d())          
        
          proper(g(X)) = [8 0 2]     [5]  
                         [0 0 5] X + [4]  
                         [0 0 2]     [3]  
                       > [8 0 2]     [4]  
                         [0 0 5] X + [4]  
                         [0 0 2]     [3]  
                       = g(proper(X))     
        
          proper(h(X)) = [8 0 2]     [5]  
                         [0 0 3] X + [0]  
                         [0 0 2]     [3]  
                       > [8 0 2]     [4]  
                         [0 0 3] X + [0]  
                         [0 0 2]     [3]  
                       = h(proper(X))     
        
          top(mark(X)) = [ 8 4 4]     [6] 
                         [10 5 5] X + [12]
                         [ 7 4 4]     [6] 
                       > [8 4 4]     [4]  
                         [8 5 5] X + [8]  
                         [4 4 3]     [2]  
                       = top(proper(X))   
        
            top(ok(X)) = [ 8 4 2]     [4] 
                         [10 5 3] X + [8] 
                         [ 7 4 2]     [2] 
                       > [ 8 4 2]     [2] 
                         [10 5 2] X + [7] 
                         [ 7 4 1]     [2] 
                       = top(active(X))   
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^3))