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

WORST_CASE(?,O(n^2))