WORST_CASE(?,O(n^1))
* Step 1: Sum WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            even(Cons(x,xs)) -> odd(xs)
            even(Nil()) -> True()
            evenodd(x) -> even(x)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
            odd(Cons(x,xs)) -> even(xs)
            odd(Nil()) -> False()
        - Signature:
            {even/1,evenodd/1,notEmpty/1,odd/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {even,evenodd,notEmpty,odd} and constructors {Cons,False
            ,Nil,True}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 2: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            even(Cons(x,xs)) -> odd(xs)
            even(Nil()) -> True()
            evenodd(x) -> even(x)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
            odd(Cons(x,xs)) -> even(xs)
            odd(Nil()) -> False()
        - Signature:
            {even/1,evenodd/1,notEmpty/1,odd/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {even,evenodd,notEmpty,odd} and constructors {Cons,False
            ,Nil,True}
    + 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:
          {even,evenodd,notEmpty,odd}
        TcT has computed the following interpretation:
              p(Cons) = 2
             p(False) = 0
               p(Nil) = 1
              p(True) = 0
              p(even) = 0
           p(evenodd) = 0
          p(notEmpty) = 8
               p(odd) = 0
        
        Following rules are strictly oriented:
        notEmpty(Cons(x,xs)) = 8      
                             > 0      
                             = True() 
        
             notEmpty(Nil()) = 8      
                             > 0      
                             = False()
        
        
        Following rules are (at-least) weakly oriented:
        even(Cons(x,xs)) =  0       
                         >= 0       
                         =  odd(xs) 
        
             even(Nil()) =  0       
                         >= 0       
                         =  True()  
        
              evenodd(x) =  0       
                         >= 0       
                         =  even(x) 
        
         odd(Cons(x,xs)) =  0       
                         >= 0       
                         =  even(xs)
        
              odd(Nil()) =  0       
                         >= 0       
                         =  False() 
        
* Step 3: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            even(Cons(x,xs)) -> odd(xs)
            even(Nil()) -> True()
            evenodd(x) -> even(x)
            odd(Cons(x,xs)) -> even(xs)
            odd(Nil()) -> False()
        - Weak TRS:
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Signature:
            {even/1,evenodd/1,notEmpty/1,odd/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {even,evenodd,notEmpty,odd} and constructors {Cons,False
            ,Nil,True}
    + 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:
          {even,evenodd,notEmpty,odd}
        TcT has computed the following interpretation:
              p(Cons) = 0 
             p(False) = 2 
               p(Nil) = 0 
              p(True) = 2 
              p(even) = 2 
           p(evenodd) = 10
          p(notEmpty) = 2 
               p(odd) = 2 
        
        Following rules are strictly oriented:
        evenodd(x) = 10     
                   > 2      
                   = even(x)
        
        
        Following rules are (at-least) weakly oriented:
            even(Cons(x,xs)) =  2       
                             >= 2       
                             =  odd(xs) 
        
                 even(Nil()) =  2       
                             >= 2       
                             =  True()  
        
        notEmpty(Cons(x,xs)) =  2       
                             >= 2       
                             =  True()  
        
             notEmpty(Nil()) =  2       
                             >= 2       
                             =  False() 
        
             odd(Cons(x,xs)) =  2       
                             >= 2       
                             =  even(xs)
        
                  odd(Nil()) =  2       
                             >= 2       
                             =  False() 
        
* Step 4: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            even(Cons(x,xs)) -> odd(xs)
            even(Nil()) -> True()
            odd(Cons(x,xs)) -> even(xs)
            odd(Nil()) -> False()
        - Weak TRS:
            evenodd(x) -> even(x)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
        - Signature:
            {even/1,evenodd/1,notEmpty/1,odd/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {even,evenodd,notEmpty,odd} and constructors {Cons,False
            ,Nil,True}
    + 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:
          {even,evenodd,notEmpty,odd}
        TcT has computed the following interpretation:
              p(Cons) = 4 + x1 + x2
             p(False) = 0          
               p(Nil) = 4          
              p(True) = 8          
              p(even) = 10 + 4*x1  
           p(evenodd) = 11 + 12*x1 
          p(notEmpty) = 13 + 4*x1  
               p(odd) = 15 + 4*x1  
        
        Following rules are strictly oriented:
        even(Cons(x,xs)) = 26 + 4*x + 4*xs
                         > 15 + 4*xs      
                         = odd(xs)        
        
             even(Nil()) = 26             
                         > 8              
                         = True()         
        
         odd(Cons(x,xs)) = 31 + 4*x + 4*xs
                         > 10 + 4*xs      
                         = even(xs)       
        
              odd(Nil()) = 31             
                         > 0              
                         = False()        
        
        
        Following rules are (at-least) weakly oriented:
                  evenodd(x) =  11 + 12*x      
                             >= 10 + 4*x       
                             =  even(x)        
        
        notEmpty(Cons(x,xs)) =  29 + 4*x + 4*xs
                             >= 8              
                             =  True()         
        
             notEmpty(Nil()) =  29             
                             >= 0              
                             =  False()        
        
* Step 5: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            even(Cons(x,xs)) -> odd(xs)
            even(Nil()) -> True()
            evenodd(x) -> even(x)
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
            odd(Cons(x,xs)) -> even(xs)
            odd(Nil()) -> False()
        - Signature:
            {even/1,evenodd/1,notEmpty/1,odd/1} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {even,evenodd,notEmpty,odd} and constructors {Cons,False
            ,Nil,True}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))