WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            rev(++(x,x)) -> rev(x)
            rev(++(x,y)) -> ++(rev(y),rev(x))
            rev(a()) -> a()
            rev(b()) -> b()
        - Signature:
            {rev/1} / {++/2,a/0,b/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {rev} and constructors {++,a,b}
    + 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(++) = {1,2}
        
        Following symbols are considered usable:
          {rev}
        TcT has computed the following interpretation:
           p(++) = [1] x1 + [1] x2 + [8]
            p(a) = [1]                  
            p(b) = [5]                  
          p(rev) = [2] x1 + [7]         
        
        Following rules are strictly oriented:
        rev(++(x,x)) = [4] x + [23]        
                     > [2] x + [7]         
                     = rev(x)              
        
        rev(++(x,y)) = [2] x + [2] y + [23]
                     > [2] x + [2] y + [22]
                     = ++(rev(y),rev(x))   
        
            rev(a()) = [9]                 
                     > [1]                 
                     = a()                 
        
            rev(b()) = [17]                
                     > [5]                 
                     = b()                 
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))