WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            ++(x,nil()) -> x
            ++(++(x,y),z) -> ++(x,++(y,z))
            ++(.(x,y),z) -> .(x,++(y,z))
            ++(nil(),y) -> y
        - Signature:
            {++/2} / {./2,nil/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {++} and constructors {.,nil}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(++) = {2},
          uargs(.) = {2}
        
        Following symbols are considered usable:
          {++}
        TcT has computed the following interpretation:
           p(++) = 3 + 4*x1 + x2
            p(.) = 5 + x2       
          p(nil) = 7            
        
        Following rules are strictly oriented:
          ++(x,nil()) = 10 + 4*x           
                      > x                  
                      = x                  
        
        ++(++(x,y),z) = 15 + 16*x + 4*y + z
                      > 6 + 4*x + 4*y + z  
                      = ++(x,++(y,z))      
        
         ++(.(x,y),z) = 23 + 4*y + z       
                      > 8 + 4*y + z        
                      = .(x,++(y,z))       
        
          ++(nil(),y) = 31 + y             
                      > y                  
                      = y                  
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))