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

WORST_CASE(?,O(n^2))