WORST_CASE(?,O(n^1))
* Step 1: NaturalPI 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:
        NaturalPI {shape = StronglyLinear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(stronglyLinear):
        The following argument positions are considered usable:
          none
        
        Following symbols are considered usable:
          {goal,list,notEmpty}
        TcT has computed the following interpretation:
                    p(Cons) = 2 + x1 + x2
                   p(False) = 14         
                     p(Nil) = 14         
                    p(True) = 5          
                    p(goal) = 3 + x1     
          p(isEmpty[Match]) = 10         
                    p(list) = x1         
                p(notEmpty) = 13 + x1    
        
        Following rules are strictly oriented:
                     goal(x) = 3 + x                
                             > x                    
                             = list(x)              
        
            list(Cons(x,xs)) = 2 + x + xs           
                             > xs                   
                             = list(xs)             
        
                 list(Nil()) = 14                   
                             > 5                    
                             = True()               
        
                 list(Nil()) = 14                   
                             > 10                   
                             = isEmpty[Match](Nil())
        
        notEmpty(Cons(x,xs)) = 15 + x + xs          
                             > 5                    
                             = True()               
        
             notEmpty(Nil()) = 27                   
                             > 14                   
                             = False()              
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))