WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            goal(x) -> list(x)
            list(Cons(x,xs)) -> list(xs)
            list(Nil()) -> True()
            list(Nil()) -> isEmpty[Match](Nil())
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Signature:
            {goal/1,list/1,notEmpty/1} / {Cons/2,False/0,Nil/0,True/0,isEmpty[Match]/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {goal,list,notEmpty} and constructors {Cons,False,Nil,True
            ,isEmpty[Match]}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, 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:
          none
        
        Following symbols are considered usable:
          {goal,list,notEmpty}
        TcT has computed the following interpretation:
                    p(Cons) = [1] x1 + [1] x2 + [4]
                   p(False) = [0]                  
                     p(Nil) = [0]                  
                    p(True) = [0]                  
                    p(goal) = [2] x1 + [7]         
          p(isEmpty[Match]) = [0]                  
                    p(list) = [2] x1 + [5]         
                p(notEmpty) = [15]                 
        
        Following rules are strictly oriented:
                     goal(x) = [2] x + [7]          
                             > [2] x + [5]          
                             = list(x)              
        
            list(Cons(x,xs)) = [2] x + [2] xs + [13]
                             > [2] xs + [5]         
                             = list(xs)             
        
                 list(Nil()) = [5]                  
                             > [0]                  
                             = True()               
        
                 list(Nil()) = [5]                  
                             > [0]                  
                             = isEmpty[Match](Nil())
        
        notEmpty(Cons(x,xs)) = [15]                 
                             > [0]                  
                             = True()               
        
             notEmpty(Nil()) = [15]                 
                             > [0]                  
                             = False()              
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))