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(t()) -> 1()
        - Signature:
            {D/1} / {*/2,+/2,-/2,0/0,1/0,constant/0,t/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {D} and constructors {*,+,-,0,1,constant,t}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(*) = {2},
          uargs(+) = {1,2},
          uargs(-) = {1,2}
        
        Following symbols are considered usable:
          {D}
        TcT has computed the following interpretation:
                 p(*) = 1 + x1 + x2  
                 p(+) = 1 + x1 + x2  
                 p(-) = 2 + x1 + x2  
                 p(0) = 0            
                 p(1) = 0            
                 p(D) = 2*x1 + 2*x1^2
          p(constant) = 1            
                 p(t) = 1            
        
        Following rules are strictly oriented:
            D(*(x,y)) = 4 + 6*x + 4*x*y + 2*x^2 + 6*y + 2*y^2   
                      > 3 + 3*x + 2*x^2 + 3*y + 2*y^2           
                      = +(*(y,D(x)),*(x,D(y)))                  
        
            D(+(x,y)) = 4 + 6*x + 4*x*y + 2*x^2 + 6*y + 2*y^2   
                      > 1 + 2*x + 2*x^2 + 2*y + 2*y^2           
                      = +(D(x),D(y))                            
        
            D(-(x,y)) = 12 + 10*x + 4*x*y + 2*x^2 + 10*y + 2*y^2
                      > 2 + 2*x + 2*x^2 + 2*y + 2*y^2           
                      = -(D(x),D(y))                            
        
        D(constant()) = 4                                       
                      > 0                                       
                      = 0()                                     
        
               D(t()) = 4                                       
                      > 0                                       
                      = 1()                                     
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))