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 = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          none
        
        Following symbols are considered usable:
          {goal,list,notEmpty}
        TcT has computed the following interpretation:
                    p(Cons) = 0
                   p(False) = 0
                     p(Nil) = 0
                    p(True) = 0
                    p(goal) = 8
          p(isEmpty[Match]) = 0
                    p(list) = 0
                p(notEmpty) = 0
        
        Following rules are strictly oriented:
        goal(x) = 8      
                > 0      
                = list(x)
        
        
        Following rules are (at-least) weakly oriented:
            list(Cons(x,xs)) =  0                    
                             >= 0                    
                             =  list(xs)             
        
                 list(Nil()) =  0                    
                             >= 0                    
                             =  True()               
        
                 list(Nil()) =  0                    
                             >= 0                    
                             =  isEmpty[Match](Nil())
        
        notEmpty(Cons(x,xs)) =  0                    
                             >= 0                    
                             =  True()               
        
             notEmpty(Nil()) =  0                    
                             >= 0                    
                             =  False()              
        
* Step 2: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            list(Cons(x,xs)) -> list(xs)
            list(Nil()) -> True()
            list(Nil()) -> isEmpty[Match](Nil())
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Weak TRS:
            goal(x) -> list(x)
        - 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 = Just any strict-rules}
    + 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) = [0]
                   p(False) = [0]
                     p(Nil) = [0]
                    p(True) = [0]
                    p(goal) = [6]
          p(isEmpty[Match]) = [6]
                    p(list) = [6]
                p(notEmpty) = [0]
        
        Following rules are strictly oriented:
        list(Nil()) = [6]   
                    > [0]   
                    = True()
        
        
        Following rules are (at-least) weakly oriented:
                     goal(x) =  [6]                  
                             >= [6]                  
                             =  list(x)              
        
            list(Cons(x,xs)) =  [6]                  
                             >= [6]                  
                             =  list(xs)             
        
                 list(Nil()) =  [6]                  
                             >= [6]                  
                             =  isEmpty[Match](Nil())
        
        notEmpty(Cons(x,xs)) =  [0]                  
                             >= [0]                  
                             =  True()               
        
             notEmpty(Nil()) =  [0]                  
                             >= [0]                  
                             =  False()              
        
* Step 3: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            list(Cons(x,xs)) -> list(xs)
            list(Nil()) -> isEmpty[Match](Nil())
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Weak TRS:
            goal(x) -> list(x)
            list(Nil()) -> True()
        - 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 = Just any strict-rules}
    + 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] x2 + [8] 
                   p(False) = [1]          
                     p(Nil) = [1]          
                    p(True) = [0]          
                    p(goal) = [8] x1 + [9] 
          p(isEmpty[Match]) = [0]          
                    p(list) = [0]          
                p(notEmpty) = [1] x1 + [14]
        
        Following rules are strictly oriented:
        notEmpty(Cons(x,xs)) = [1] xs + [22]
                             > [0]          
                             = True()       
        
             notEmpty(Nil()) = [15]         
                             > [1]          
                             = False()      
        
        
        Following rules are (at-least) weakly oriented:
                 goal(x) =  [8] x + [9]          
                         >= [0]                  
                         =  list(x)              
        
        list(Cons(x,xs)) =  [0]                  
                         >= [0]                  
                         =  list(xs)             
        
             list(Nil()) =  [0]                  
                         >= [0]                  
                         =  True()               
        
             list(Nil()) =  [0]                  
                         >= [0]                  
                         =  isEmpty[Match](Nil())
        
* Step 4: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            list(Cons(x,xs)) -> list(xs)
            list(Nil()) -> isEmpty[Match](Nil())
        - Weak TRS:
            goal(x) -> list(x)
            list(Nil()) -> True()
            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 = Just any strict-rules}
    + 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) = [0]
                   p(False) = [0]
                     p(Nil) = [0]
                    p(True) = [0]
                    p(goal) = [2]
          p(isEmpty[Match]) = [0]
                    p(list) = [2]
                p(notEmpty) = [5]
        
        Following rules are strictly oriented:
        list(Nil()) = [2]                  
                    > [0]                  
                    = isEmpty[Match](Nil())
        
        
        Following rules are (at-least) weakly oriented:
                     goal(x) =  [2]     
                             >= [2]     
                             =  list(x) 
        
            list(Cons(x,xs)) =  [2]     
                             >= [2]     
                             =  list(xs)
        
                 list(Nil()) =  [2]     
                             >= [0]     
                             =  True()  
        
        notEmpty(Cons(x,xs)) =  [5]     
                             >= [0]     
                             =  True()  
        
             notEmpty(Nil()) =  [5]     
                             >= [0]     
                             =  False() 
        
* Step 5: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            list(Cons(x,xs)) -> list(xs)
        - Weak TRS:
            goal(x) -> list(x)
            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 = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          none
        
        Following symbols are considered usable:
          {goal,list,notEmpty}
        TcT has computed the following interpretation:
                    p(Cons) = 8 + x1 + x2
                   p(False) = 11         
                     p(Nil) = 9          
                    p(True) = 7          
                    p(goal) = 6 + 2*x1   
          p(isEmpty[Match]) = 15         
                    p(list) = 4 + 2*x1   
                p(notEmpty) = 6 + 2*x1   
        
        Following rules are strictly oriented:
        list(Cons(x,xs)) = 20 + 2*x + 2*xs
                         > 4 + 2*xs       
                         = list(xs)       
        
        
        Following rules are (at-least) weakly oriented:
                     goal(x) =  6 + 2*x              
                             >= 4 + 2*x              
                             =  list(x)              
        
                 list(Nil()) =  22                   
                             >= 7                    
                             =  True()               
        
                 list(Nil()) =  22                   
                             >= 15                   
                             =  isEmpty[Match](Nil())
        
        notEmpty(Cons(x,xs)) =  22 + 2*x + 2*xs      
                             >= 7                    
                             =  True()               
        
             notEmpty(Nil()) =  24                   
                             >= 11                   
                             =  False()              
        
* Step 6: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak 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:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))