WORST_CASE(?,O(n^2))
* Step 1: NaturalPI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            D(*(x,y)) -> +(*(y,D(x)),*(x,D(y)))
            D(+(x,y)) -> +(D(x),D(y))
            D(-(x,y)) -> -(D(x),D(y))
            D(constant()) -> 0()
            D(div(x,y)) -> -(div(D(x),y),div(*(x,D(y)),pow(y,2())))
            D(ln(x)) -> div(D(x),x)
            D(minus(x)) -> minus(D(x))
            D(pow(x,y)) -> +(*(*(y,pow(x,-(y,1()))),D(x)),*(*(pow(x,y),ln(x)),D(y)))
            D(t()) -> 1()
        - Signature:
            {D/1} / {*/2,+/2,-/2,0/0,1/0,2/0,constant/0,div/2,ln/1,minus/1,pow/2,t/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {D} and constructors {*,+,-,0,1,2,constant,div,ln,minus
            ,pow,t}
    + 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(*) = {2},
          uargs(+) = {1,2},
          uargs(-) = {1,2},
          uargs(div) = {1},
          uargs(minus) = {1}
        
        Following symbols are considered usable:
          {D}
        TcT has computed the following interpretation:
                 p(*) = 1 + x1 + x2  
                 p(+) = 1 + x1 + x2  
                 p(-) = 1 + x1 + x2  
                 p(0) = 5            
                 p(1) = 1            
                 p(2) = 2            
                 p(D) = 7*x1 + 4*x1^2
          p(constant) = 1            
               p(div) = 1 + x1 + x2  
                p(ln) = 1 + x1       
             p(minus) = 1 + x1       
               p(pow) = 1 + x1 + x2  
                 p(t) = 1            
        
        Following rules are strictly oriented:
            D(*(x,y)) = 11 + 15*x + 8*x*y + 4*x^2 + 15*y + 4*y^2                 
                      > 3 + 8*x + 4*x^2 + 8*y + 4*y^2                            
                      = +(*(y,D(x)),*(x,D(y)))                                   
        
            D(+(x,y)) = 11 + 15*x + 8*x*y + 4*x^2 + 15*y + 4*y^2                 
                      > 1 + 7*x + 4*x^2 + 7*y + 4*y^2                            
                      = +(D(x),D(y))                                             
        
            D(-(x,y)) = 11 + 15*x + 8*x*y + 4*x^2 + 15*y + 4*y^2                 
                      > 1 + 7*x + 4*x^2 + 7*y + 4*y^2                            
                      = -(D(x),D(y))                                             
        
        D(constant()) = 11                                                       
                      > 5                                                        
                      = 0()                                                      
        
          D(div(x,y)) = 11 + 15*x + 8*x*y + 4*x^2 + 15*y + 4*y^2                 
                      > 7 + 8*x + 4*x^2 + 9*y + 4*y^2                            
                      = -(div(D(x),y),div(*(x,D(y)),pow(y,2())))                 
        
             D(ln(x)) = 11 + 15*x + 4*x^2                                        
                      > 1 + 8*x + 4*x^2                                          
                      = div(D(x),x)                                              
        
          D(minus(x)) = 11 + 15*x + 4*x^2                                        
                      > 1 + 7*x + 4*x^2                                          
                      = minus(D(x))                                              
        
          D(pow(x,y)) = 11 + 15*x + 8*x*y + 4*x^2 + 15*y + 4*y^2                 
                      > 10 + 10*x + 4*x^2 + 10*y + 4*y^2                         
                      = +(*(*(y,pow(x,-(y,1()))),D(x)),*(*(pow(x,y),ln(x)),D(y)))
        
               D(t()) = 11                                                       
                      > 1                                                        
                      = 1()                                                      
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))