WORST_CASE(Omega(n^1),O(n^1))
* Step 1: Sum WORST_CASE(Omega(n^1),O(n^1))
    + Considered Problem:
        - Strict TRS:
            compS_f#1(compS_f(x2),x1) -> compS_f#1(x2,S(x1))
            compS_f#1(id(),x3) -> S(x3)
            iter#3(0()) -> id()
            iter#3(S(x6)) -> compS_f(iter#3(x6))
            main(0()) -> 0()
            main(S(x9)) -> compS_f#1(iter#3(x9),0())
        - Signature:
            {compS_f#1/2,iter#3/1,main/1} / {0/0,S/1,compS_f/1,id/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {compS_f#1,iter#3,main} and constructors {0,S,compS_f,id}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
** Step 1.a:1: DecreasingLoops WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            compS_f#1(compS_f(x2),x1) -> compS_f#1(x2,S(x1))
            compS_f#1(id(),x3) -> S(x3)
            iter#3(0()) -> id()
            iter#3(S(x6)) -> compS_f(iter#3(x6))
            main(0()) -> 0()
            main(S(x9)) -> compS_f#1(iter#3(x9),0())
        - Signature:
            {compS_f#1/2,iter#3/1,main/1} / {0/0,S/1,compS_f/1,id/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {compS_f#1,iter#3,main} and constructors {0,S,compS_f,id}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          compS_f#1(x,y){x -> compS_f(x)} =
            compS_f#1(compS_f(x),y) ->^+ compS_f#1(x,S(y))
              = C[compS_f#1(x,S(y)) = compS_f#1(x,y){y -> S(y)}]

** Step 1.b:1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            compS_f#1(compS_f(x2),x1) -> compS_f#1(x2,S(x1))
            compS_f#1(id(),x3) -> S(x3)
            iter#3(0()) -> id()
            iter#3(S(x6)) -> compS_f(iter#3(x6))
            main(0()) -> 0()
            main(S(x9)) -> compS_f#1(iter#3(x9),0())
        - Signature:
            {compS_f#1/2,iter#3/1,main/1} / {0/0,S/1,compS_f/1,id/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {compS_f#1,iter#3,main} and constructors {0,S,compS_f,id}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(compS_f) = {1},
          uargs(compS_f#1) = {1}
        
        Following symbols are considered usable:
          {compS_f#1,iter#3,main}
        TcT has computed the following interpretation:
                  p(0) = [1]                  
                  p(S) = [1] x1 + [2]         
            p(compS_f) = [1] x1 + [5]         
          p(compS_f#1) = [1] x1 + [2] x2 + [0]
                 p(id) = [3]                  
             p(iter#3) = [8] x1 + [0]         
               p(main) = [8] x1 + [3]         
        
        Following rules are strictly oriented:
        compS_f#1(compS_f(x2),x1) = [2] x1 + [1] x2 + [5]    
                                  > [2] x1 + [1] x2 + [4]    
                                  = compS_f#1(x2,S(x1))      
        
               compS_f#1(id(),x3) = [2] x3 + [3]             
                                  > [1] x3 + [2]             
                                  = S(x3)                    
        
                      iter#3(0()) = [8]                      
                                  > [3]                      
                                  = id()                     
        
                    iter#3(S(x6)) = [8] x6 + [16]            
                                  > [8] x6 + [5]             
                                  = compS_f(iter#3(x6))      
        
                        main(0()) = [11]                     
                                  > [1]                      
                                  = 0()                      
        
                      main(S(x9)) = [8] x9 + [19]            
                                  > [8] x9 + [2]             
                                  = compS_f#1(iter#3(x9),0())
        
        
        Following rules are (at-least) weakly oriented:
        
** Step 1.b:2: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            compS_f#1(compS_f(x2),x1) -> compS_f#1(x2,S(x1))
            compS_f#1(id(),x3) -> S(x3)
            iter#3(0()) -> id()
            iter#3(S(x6)) -> compS_f(iter#3(x6))
            main(0()) -> 0()
            main(S(x9)) -> compS_f#1(iter#3(x9),0())
        - Signature:
            {compS_f#1/2,iter#3/1,main/1} / {0/0,S/1,compS_f/1,id/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {compS_f#1,iter#3,main} and constructors {0,S,compS_f,id}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(Omega(n^1),O(n^1))