WORST_CASE(?,O(n^2))
* Step 1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            dx(X) -> one()
            dx(a()) -> zero()
            dx(div(ALPHA,BETA)) -> minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two()))))
            dx(exp(ALPHA,BETA)) -> plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA)))
                                       ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA))))
            dx(ln(ALPHA)) -> div(dx(ALPHA),ALPHA)
            dx(minus(ALPHA,BETA)) -> minus(dx(ALPHA),dx(BETA))
            dx(neg(ALPHA)) -> neg(dx(ALPHA))
            dx(plus(ALPHA,BETA)) -> plus(dx(ALPHA),dx(BETA))
            dx(times(ALPHA,BETA)) -> plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA)))
        - Signature:
            {dx/1} / {a/0,div/2,exp/2,ln/1,minus/2,neg/1,one/0,plus/2,times/2,two/0,zero/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {dx} and constructors {a,div,exp,ln,minus,neg,one,plus
            ,times,two,zero}
    + Applied Processor:
        NaturalPI {shape = Quadratic, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(quadratic):
        The following argument positions are considered usable:
          uargs(div) = {1},
          uargs(minus) = {1,2},
          uargs(neg) = {1},
          uargs(plus) = {1,2},
          uargs(times) = {2}
        
        Following symbols are considered usable:
          {dx}
        TcT has computed the following interpretation:
              p(a) = 1                
            p(div) = 1 + x1 + x2      
             p(dx) = 1 + 7*x1 + 4*x1^2
            p(exp) = 1 + x1 + x2      
             p(ln) = 1 + x1           
          p(minus) = 1 + x1 + x2      
            p(neg) = 1 + x1           
            p(one) = 0                
           p(plus) = 1 + x1 + x2      
          p(times) = 1 + x1 + x2      
            p(two) = 3                
           p(zero) = 2                
        
        Following rules are strictly oriented:
                        dx(X) = 1 + 7*X + 4*X^2                                                      
                              > 0                                                                    
                              = one()                                                                
        
                      dx(a()) = 12                                                                   
                              > 2                                                                    
                              = zero()                                                               
        
          dx(div(ALPHA,BETA)) = 12 + 15*ALPHA + 8*ALPHA*BETA + 4*ALPHA^2 + 15*BETA + 4*BETA^2        
                              > 10 + 8*ALPHA + 4*ALPHA^2 + 9*BETA + 4*BETA^2                         
                              = minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two()))))
        
          dx(exp(ALPHA,BETA)) = 12 + 15*ALPHA + 8*ALPHA*BETA + 4*ALPHA^2 + 15*BETA + 4*BETA^2        
                              > 11 + 10*ALPHA + 4*ALPHA^2 + 10*BETA + 4*BETA^2                       
                              = plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA)))       
                                    ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA))))               
        
                dx(ln(ALPHA)) = 12 + 15*ALPHA + 4*ALPHA^2                                            
                              > 2 + 8*ALPHA + 4*ALPHA^2                                              
                              = div(dx(ALPHA),ALPHA)                                                 
        
        dx(minus(ALPHA,BETA)) = 12 + 15*ALPHA + 8*ALPHA*BETA + 4*ALPHA^2 + 15*BETA + 4*BETA^2        
                              > 3 + 7*ALPHA + 4*ALPHA^2 + 7*BETA + 4*BETA^2                          
                              = minus(dx(ALPHA),dx(BETA))                                            
        
               dx(neg(ALPHA)) = 12 + 15*ALPHA + 4*ALPHA^2                                            
                              > 2 + 7*ALPHA + 4*ALPHA^2                                              
                              = neg(dx(ALPHA))                                                       
        
         dx(plus(ALPHA,BETA)) = 12 + 15*ALPHA + 8*ALPHA*BETA + 4*ALPHA^2 + 15*BETA + 4*BETA^2        
                              > 3 + 7*ALPHA + 4*ALPHA^2 + 7*BETA + 4*BETA^2                          
                              = plus(dx(ALPHA),dx(BETA))                                             
        
        dx(times(ALPHA,BETA)) = 12 + 15*ALPHA + 8*ALPHA*BETA + 4*ALPHA^2 + 15*BETA + 4*BETA^2        
                              > 5 + 8*ALPHA + 4*ALPHA^2 + 8*BETA + 4*BETA^2                          
                              = plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA)))                    
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))