WORST_CASE(Omega(n^1),O(n^1))
* Step 1: Sum WORST_CASE(Omega(n^1),O(n^1))
    + Considered Problem:
        - Strict TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            activate(n__f(X)) -> f(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> f(g(n__f(n__a())))
        - Signature:
            {a/0,activate/1,f/1} / {g/1,n__a/0,n__f/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f} and constructors {g,n__a,n__f}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
** Step 1.a:1: DecreasingLoops WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            activate(n__f(X)) -> f(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> f(g(n__f(n__a())))
        - Signature:
            {a/0,activate/1,f/1} / {g/1,n__a/0,n__f/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f} and constructors {g,n__a,n__f}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          activate(x){x -> n__f(x)} =
            activate(n__f(x)) ->^+ f(activate(x))
              = C[activate(x) = activate(x){}]

** Step 1.b:1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            activate(n__f(X)) -> f(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> f(g(n__f(n__a())))
        - Signature:
            {a/0,activate/1,f/1} / {g/1,n__a/0,n__f/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f} and constructors {g,n__a,n__f}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(f) = {1}
        
        Following symbols are considered usable:
          {a,activate,f}
        TcT has computed the following interpretation:
                 p(a) = 8      
          p(activate) = 12 + x1
                 p(f) = 8 + x1 
                 p(g) = 4 + x1 
              p(n__a) = 0      
              p(n__f) = 8 + x1 
        
        Following rules are strictly oriented:
                     a() = 8                 
                         > 0                 
                         = n__a()            
        
             activate(X) = 12 + X            
                         > X                 
                         = X                 
        
        activate(n__a()) = 12                
                         > 8                 
                         = a()               
        
               f(f(a())) = 24                
                         > 20                
                         = f(g(n__f(n__a())))
        
        
        Following rules are (at-least) weakly oriented:
        activate(n__f(X)) =  20 + X        
                          >= 20 + X        
                          =  f(activate(X))
        
                     f(X) =  8 + X         
                          >= 8 + X         
                          =  n__f(X)       
        
** Step 1.b:2: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__f(X)) -> f(activate(X))
            f(X) -> n__f(X)
        - Weak TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            f(f(a())) -> f(g(n__f(n__a())))
        - Signature:
            {a/0,activate/1,f/1} / {g/1,n__a/0,n__f/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f} and constructors {g,n__a,n__f}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(f) = {1}
        
        Following symbols are considered usable:
          {a,activate,f}
        TcT has computed the following interpretation:
                 p(a) = 5       
          p(activate) = 6 + 8*x1
                 p(f) = 3 + x1  
                 p(g) = x1      
              p(n__a) = 0       
              p(n__f) = 3 + x1  
        
        Following rules are strictly oriented:
        activate(n__f(X)) = 30 + 8*X      
                          > 9 + 8*X       
                          = f(activate(X))
        
        
        Following rules are (at-least) weakly oriented:
                     a() =  5                 
                         >= 0                 
                         =  n__a()            
        
             activate(X) =  6 + 8*X           
                         >= X                 
                         =  X                 
        
        activate(n__a()) =  6                 
                         >= 5                 
                         =  a()               
        
                    f(X) =  3 + X             
                         >= 3 + X             
                         =  n__f(X)           
        
               f(f(a())) =  11                
                         >= 6                 
                         =  f(g(n__f(n__a())))
        
** Step 1.b:3: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            f(X) -> n__f(X)
        - Weak TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            activate(n__f(X)) -> f(activate(X))
            f(f(a())) -> f(g(n__f(n__a())))
        - Signature:
            {a/0,activate/1,f/1} / {g/1,n__a/0,n__f/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f} and constructors {g,n__a,n__f}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(f) = {1}
        
        Following symbols are considered usable:
          {a,activate,f}
        TcT has computed the following interpretation:
                 p(a) = 0     
          p(activate) = 8*x1  
                 p(f) = 3 + x1
                 p(g) = 0     
              p(n__a) = 0     
              p(n__f) = 1 + x1
        
        Following rules are strictly oriented:
        f(X) = 3 + X  
             > 1 + X  
             = n__f(X)
        
        
        Following rules are (at-least) weakly oriented:
                      a() =  0                 
                          >= 0                 
                          =  n__a()            
        
              activate(X) =  8*X               
                          >= X                 
                          =  X                 
        
         activate(n__a()) =  0                 
                          >= 0                 
                          =  a()               
        
        activate(n__f(X)) =  8 + 8*X           
                          >= 3 + 8*X           
                          =  f(activate(X))    
        
                f(f(a())) =  6                 
                          >= 3                 
                          =  f(g(n__f(n__a())))
        
** Step 1.b:4: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            activate(n__f(X)) -> f(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> f(g(n__f(n__a())))
        - Signature:
            {a/0,activate/1,f/1} / {g/1,n__a/0,n__f/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f} and constructors {g,n__a,n__f}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

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