WORST_CASE(?,O(n^3))
* Step 1: NaturalMI WORST_CASE(?,O(n^3))
    + Considered Problem:
        - Strict TRS:
            active(f(X)) -> f(active(X))
            active(f(f(a()))) -> mark(f(g(f(a()))))
            f(mark(X)) -> mark(f(X))
            f(ok(X)) -> ok(f(X))
            g(ok(X)) -> ok(g(X))
            proper(a()) -> ok(a())
            proper(f(X)) -> f(proper(X))
            proper(g(X)) -> g(proper(X))
            top(mark(X)) -> top(proper(X))
            top(ok(X)) -> top(active(X))
        - Signature:
            {active/1,f/1,g/1,proper/1,top/1} / {a/0,mark/1,ok/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {active,f,g,proper,top} and constructors {a,mark,ok}
    + Applied Processor:
        NaturalMI {miDimension = 3, miDegree = 3, 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(f) = {1},
          uargs(g) = {1},
          uargs(mark) = {1},
          uargs(ok) = {1},
          uargs(top) = {1}
        
        Following symbols are considered usable:
          {active,f,g,proper,top}
        TcT has computed the following interpretation:
               p(a) = [1]             
                      [1]             
                      [0]             
          p(active) = [1 0 1]      [0]
                      [0 1 0] x1 + [0]
                      [0 0 1]      [0]
               p(f) = [1 1 1]      [0]
                      [0 2 0] x1 + [0]
                      [0 0 1]      [1]
               p(g) = [1 0 1]      [0]
                      [0 0 0] x1 + [0]
                      [0 0 1]      [1]
            p(mark) = [1 0 0]      [1]
                      [0 1 1] x1 + [1]
                      [0 0 0]      [2]
              p(ok) = [1 0 1]      [1]
                      [0 1 0] x1 + [0]
                      [0 0 1]      [2]
          p(proper) = [1 0 3]      [3]
                      [0 1 0] x1 + [0]
                      [0 0 1]      [2]
             p(top) = [1 3 0]      [0]
                      [0 0 0] x1 + [0]
                      [0 1 1]      [0]
        
        Following rules are strictly oriented:
             active(f(X)) = [1 1 2]     [1]   
                            [0 2 0] X + [0]   
                            [0 0 1]     [1]   
                          > [1 1 2]     [0]   
                            [0 2 0] X + [0]   
                            [0 0 1]     [1]   
                          = f(active(X))      
        
        active(f(f(a()))) = [7]               
                            [4]               
                            [2]               
                          > [6]               
                            [4]               
                            [2]               
                          = mark(f(g(f(a()))))
        
               f(mark(X)) = [1 1 1]     [4]   
                            [0 2 2] X + [2]   
                            [0 0 0]     [3]   
                          > [1 1 1]     [1]   
                            [0 2 1] X + [2]   
                            [0 0 0]     [2]   
                          = mark(f(X))        
        
                 f(ok(X)) = [1 1 2]     [3]   
                            [0 2 0] X + [0]   
                            [0 0 1]     [3]   
                          > [1 1 2]     [2]   
                            [0 2 0] X + [0]   
                            [0 0 1]     [3]   
                          = ok(f(X))          
        
                 g(ok(X)) = [1 0 2]     [3]   
                            [0 0 0] X + [0]   
                            [0 0 1]     [3]   
                          > [1 0 2]     [2]   
                            [0 0 0] X + [0]   
                            [0 0 1]     [3]   
                          = ok(g(X))          
        
              proper(a()) = [4]               
                            [1]               
                            [2]               
                          > [2]               
                            [1]               
                            [2]               
                          = ok(a())           
        
             proper(f(X)) = [1 1 4]     [6]   
                            [0 2 0] X + [0]   
                            [0 0 1]     [3]   
                          > [1 1 4]     [5]   
                            [0 2 0] X + [0]   
                            [0 0 1]     [3]   
                          = f(proper(X))      
        
             proper(g(X)) = [1 0 4]     [6]   
                            [0 0 0] X + [0]   
                            [0 0 1]     [3]   
                          > [1 0 4]     [5]   
                            [0 0 0] X + [0]   
                            [0 0 1]     [3]   
                          = g(proper(X))      
        
             top(mark(X)) = [1 3 3]     [4]   
                            [0 0 0] X + [0]   
                            [0 1 1]     [3]   
                          > [1 3 3]     [3]   
                            [0 0 0] X + [0]   
                            [0 1 1]     [2]   
                          = top(proper(X))    
        
               top(ok(X)) = [1 3 1]     [1]   
                            [0 0 0] X + [0]   
                            [0 1 1]     [2]   
                          > [1 3 1]     [0]   
                            [0 0 0] X + [0]   
                            [0 1 1]     [0]   
                          = top(active(X))    
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^3))