WORST_CASE(?,O(n^2))
* Step 1: NaturalMI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            fac(s(x)) -> *(fac(p(s(x))),s(x))
            p(s(0())) -> 0()
            p(s(s(x))) -> s(p(s(x)))
        - Signature:
            {fac/1,p/1} / {*/2,0/0,s/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {fac,p} and constructors {*,0,s}
    + Applied Processor:
        NaturalMI {miDimension = 3, miDegree = 3, 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(*) = {1},
          uargs(fac) = {1},
          uargs(s) = {1}
        
        Following symbols are considered usable:
          {fac,p}
        TcT has computed the following interpretation:
            p(*) = [1 0 0]      [0]
                   [0 0 1] x1 + [0]
                   [0 0 0]      [0]
            p(0) = [2]             
                   [0]             
                   [2]             
          p(fac) = [2 0 1]      [0]
                   [2 1 1] x1 + [1]
                   [0 2 0]      [0]
            p(p) = [1 0 0]      [0]
                   [0 2 0] x1 + [1]
                   [0 1 0]      [1]
            p(s) = [1 0 2]      [0]
                   [0 0 1] x1 + [0]
                   [0 0 1]      [2]
        
        Following rules are strictly oriented:
         fac(s(x)) = [2 0 5]     [2]     
                     [2 0 6] x + [3]     
                     [0 0 2]     [0]     
                   > [2 0 5]     [1]     
                     [0 0 4] x + [2]     
                     [0 0 0]     [0]     
                   = *(fac(p(s(x))),s(x))
        
         p(s(0())) = [6]                 
                     [5]                 
                     [3]                 
                   > [2]                 
                     [0]                 
                     [2]                 
                   = 0()                 
        
        p(s(s(x))) = [1 0 4]     [4]     
                     [0 0 2] x + [5]     
                     [0 0 1]     [3]     
                   > [1 0 4]     [2]     
                     [0 0 1] x + [1]     
                     [0 0 1]     [3]     
                   = s(p(s(x)))          
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^2))