WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            +Full(0(),y) -> y
            +Full(S(x),y) -> +Full(x,S(y))
            f(x) -> *(x,x)
            goal(xs) -> map(xs)
            map(Cons(x,xs)) -> Cons(f(x),map(xs))
            map(Nil()) -> Nil()
        - Weak TRS:
            *(x,0()) -> 0()
            *(x,S(0())) -> x
            *(x,S(S(y))) -> +(x,*(x,S(y)))
            *(0(),y) -> 0()
        - Signature:
            {*/2,+Full/2,f/1,goal/1,map/1} / {+/2,0/0,Cons/2,Nil/0,S/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {*,+Full,f,goal,map} and constructors {+,0,Cons,Nil,S}
    + 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(+) = {2},
          uargs(Cons) = {1,2}
        
        Following symbols are considered usable:
          {*,+Full,f,goal,map}
        TcT has computed the following interpretation:
              p(*) = [1] x1 + [2] x2 + [1] 
              p(+) = [1] x2 + [7]          
          p(+Full) = [4] x1 + [2] x2 + [14]
              p(0) = [4]                   
           p(Cons) = [1] x1 + [1] x2 + [8] 
            p(Nil) = [9]                   
              p(S) = [1] x1 + [4]          
              p(f) = [3] x1 + [8]          
           p(goal) = [8] x1 + [10]         
            p(map) = [3] x1 + [0]          
        
        Following rules are strictly oriented:
           +Full(0(),y) = [2] y + [30]         
                        > [1] y + [0]          
                        = y                    
        
          +Full(S(x),y) = [4] x + [2] y + [30] 
                        > [4] x + [2] y + [22] 
                        = +Full(x,S(y))        
        
                   f(x) = [3] x + [8]          
                        > [3] x + [1]          
                        = *(x,x)               
        
               goal(xs) = [8] xs + [10]        
                        > [3] xs + [0]         
                        = map(xs)              
        
        map(Cons(x,xs)) = [3] x + [3] xs + [24]
                        > [3] x + [3] xs + [16]
                        = Cons(f(x),map(xs))   
        
             map(Nil()) = [27]                 
                        > [9]                  
                        = Nil()                
        
        
        Following rules are (at-least) weakly oriented:
            *(x,0()) =  [1] x + [9]         
                     >= [4]                 
                     =  0()                 
        
         *(x,S(0())) =  [1] x + [17]        
                     >= [1] x + [0]         
                     =  x                   
        
        *(x,S(S(y))) =  [1] x + [2] y + [17]
                     >= [1] x + [2] y + [16]
                     =  +(x,*(x,S(y)))      
        
            *(0(),y) =  [2] y + [5]         
                     >= [4]                 
                     =  0()                 
        

WORST_CASE(?,O(n^1))