WORST_CASE(?,O(n^1))
* Step 1: NaturalMI 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:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        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) = [8]                           
               p(U11) = [2] x1 + [2] x2 + [1] x3 + [5]
               p(U12) = [2] x1 + [2] x2 + [1] x3 + [0]
          p(activate) = [1] x1 + [1]                  
              p(plus) = [1] x1 + [2] x2 + [0]         
                 p(s) = [1] x1 + [14]                 
                p(tt) = [9]                           
        
        Following rules are strictly oriented:
        U11(tt(),M,N) = [2] M + [1] N + [23]             
                      > [2] M + [1] N + [21]             
                      = U12(tt(),activate(M),activate(N))
        
        U12(tt(),M,N) = [2] M + [1] N + [18]             
                      > [2] M + [1] N + [17]             
                      = s(plus(activate(N),activate(M))) 
        
          activate(X) = [1] X + [1]                      
                      > [1] X + [0]                      
                      = X                                
        
          plus(N,0()) = [1] N + [16]                     
                      > [1] N + [0]                      
                      = N                                
        
         plus(N,s(M)) = [2] M + [1] N + [28]             
                      > [2] M + [1] N + [23]             
                      = U11(tt(),M,N)                    
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))