WORST_CASE(?,O(n^1))
* Step 1: NaturalMI 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:
        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:
          uargs(++) = {2},
          uargs(.) = {2}
        
        Following symbols are considered usable:
          {++}
        TcT has computed the following interpretation:
           p(++) = [2] x1 + [1] x2 + [1]
            p(.) = [1] x1 + [1] x2 + [8]
          p(nil) = [9]                  
        
        Following rules are strictly oriented:
          ++(x,nil()) = [2] x + [10]                
                      > [1] x + [0]                 
                      = x                           
        
        ++(++(x,y),z) = [4] x + [2] y + [1] z + [3] 
                      > [2] x + [2] y + [1] z + [2] 
                      = ++(x,++(y,z))               
        
         ++(.(x,y),z) = [2] x + [2] y + [1] z + [17]
                      > [1] x + [2] y + [1] z + [9] 
                      = .(x,++(y,z))                
        
          ++(nil(),y) = [1] y + [19]                
                      > [1] y + [0]                 
                      = y                           
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))