WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            U11(tt(),M,N) -> U12(tt(),activate(M),activate(N))
            U12(tt(),M,N) -> s(plus(activate(N),activate(M)))
            activate(X) -> X
            plus(N,0()) -> N
            plus(N,s(M)) -> U11(tt(),M,N)
        - Signature:
            {U11/3,U12/3,activate/1,plus/2} / {0/0,s/1,tt/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {U11,U12,activate,plus} and constructors {0,s,tt}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(U12) = {2,3},
          uargs(plus) = {1,2},
          uargs(s) = {1}
        
        Following symbols are considered usable:
          {U11,U12,activate,plus}
        TcT has computed the following interpretation:
                 p(0) = 0                     
               p(U11) = 12 + 12*x1 + 8*x2 + x3
               p(U12) = 13 + x1 + 8*x2 + x3   
          p(activate) = 1 + x1                
              p(plus) = 1 + x1 + 8*x2         
                 p(s) = 3 + x1                
                p(tt) = 1                     
        
        Following rules are strictly oriented:
        U11(tt(),M,N) = 24 + 8*M + N                     
                      > 23 + 8*M + N                     
                      = U12(tt(),activate(M),activate(N))
        
        U12(tt(),M,N) = 14 + 8*M + N                     
                      > 13 + 8*M + N                     
                      = s(plus(activate(N),activate(M))) 
        
          activate(X) = 1 + X                            
                      > X                                
                      = X                                
        
          plus(N,0()) = 1 + N                            
                      > N                                
                      = N                                
        
         plus(N,s(M)) = 25 + 8*M + N                     
                      > 24 + 8*M + N                     
                      = U11(tt(),M,N)                    
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))