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))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + 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))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + 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))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + 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},
          uargs(g) = {1}
        
        Following symbols are considered usable:
          {a,activate,f,g}
        TcT has computed the following interpretation:
                 p(a) = 10     
          p(activate) = 13 + x1
                 p(c) = 0      
                 p(f) = 8 + x1 
                 p(g) = x1     
              p(n__a) = 6      
              p(n__f) = 8 + x1 
              p(n__g) = x1     
        
        Following rules are strictly oriented:
                     a() = 10                         
                         > 6                          
                         = n__a()                     
        
             activate(X) = 13 + X                     
                         > X                          
                         = X                          
        
        activate(n__a()) = 19                         
                         > 10                         
                         = a()                        
        
               f(f(a())) = 26                         
                         > 0                          
                         = c(n__f(n__g(n__f(n__a()))))
        
        
        Following rules are (at-least) weakly oriented:
        activate(n__f(X)) =  21 + X        
                          >= 21 + X        
                          =  f(activate(X))
        
        activate(n__g(X)) =  13 + X        
                          >= 13 + X        
                          =  g(activate(X))
        
                     f(X) =  8 + X         
                          >= 8 + X         
                          =  n__f(X)       
        
                     g(X) =  X             
                          >= X             
                          =  n__g(X)       
        
** Step 1.b:2: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__f(X)) -> f(activate(X))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            g(X) -> n__g(X)
        - Weak TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + 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},
          uargs(g) = {1}
        
        Following symbols are considered usable:
          {a,activate,f,g}
        TcT has computed the following interpretation:
                 p(a) = 2      
          p(activate) = 8*x1   
                 p(c) = 9 + x1 
                 p(f) = 14 + x1
                 p(g) = x1     
              p(n__a) = 2      
              p(n__f) = 2 + x1 
              p(n__g) = x1     
        
        Following rules are strictly oriented:
        activate(n__f(X)) = 16 + 8*X      
                          > 14 + 8*X      
                          = f(activate(X))
        
                     f(X) = 14 + X        
                          > 2 + X         
                          = n__f(X)       
        
        
        Following rules are (at-least) weakly oriented:
                      a() =  2                          
                          >= 2                          
                          =  n__a()                     
        
              activate(X) =  8*X                        
                          >= X                          
                          =  X                          
        
         activate(n__a()) =  16                         
                          >= 2                          
                          =  a()                        
        
        activate(n__g(X)) =  8*X                        
                          >= 8*X                        
                          =  g(activate(X))             
        
                f(f(a())) =  30                         
                          >= 15                         
                          =  c(n__f(n__g(n__f(n__a()))))
        
                     g(X) =  X                          
                          >= X                          
                          =  n__g(X)                    
        
** Step 1.b:3: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__g(X)) -> g(activate(X))
            g(X) -> n__g(X)
        - 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())) -> c(n__f(n__g(n__f(n__a()))))
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + 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},
          uargs(g) = {1}
        
        Following symbols are considered usable:
          {a,activate,f,g}
        TcT has computed the following interpretation:
                 p(a) = 8        
          p(activate) = 12 + 2*x1
                 p(c) = 3 + x1   
                 p(f) = 8 + x1   
                 p(g) = 2 + x1   
              p(n__a) = 2        
              p(n__f) = 4 + x1   
              p(n__g) = 1 + x1   
        
        Following rules are strictly oriented:
        g(X) = 2 + X  
             > 1 + X  
             = n__g(X)
        
        
        Following rules are (at-least) weakly oriented:
                      a() =  8                          
                          >= 2                          
                          =  n__a()                     
        
              activate(X) =  12 + 2*X                   
                          >= X                          
                          =  X                          
        
         activate(n__a()) =  16                         
                          >= 8                          
                          =  a()                        
        
        activate(n__f(X)) =  20 + 2*X                   
                          >= 20 + 2*X                   
                          =  f(activate(X))             
        
        activate(n__g(X)) =  14 + 2*X                   
                          >= 14 + 2*X                   
                          =  g(activate(X))             
        
                     f(X) =  8 + X                      
                          >= 4 + X                      
                          =  n__f(X)                    
        
                f(f(a())) =  24                         
                          >= 14                         
                          =  c(n__f(n__g(n__f(n__a()))))
        
** Step 1.b:4: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__g(X)) -> g(activate(X))
        - 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())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + 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},
          uargs(g) = {1}
        
        Following symbols are considered usable:
          {a,activate,f,g}
        TcT has computed the following interpretation:
                 p(a) = 6     
          p(activate) = 8*x1  
                 p(c) = 0     
                 p(f) = x1    
                 p(g) = 2 + x1
              p(n__a) = 1     
              p(n__f) = x1    
              p(n__g) = 2 + x1
        
        Following rules are strictly oriented:
        activate(n__g(X)) = 16 + 8*X      
                          > 2 + 8*X       
                          = g(activate(X))
        
        
        Following rules are (at-least) weakly oriented:
                      a() =  6                          
                          >= 1                          
                          =  n__a()                     
        
              activate(X) =  8*X                        
                          >= X                          
                          =  X                          
        
         activate(n__a()) =  8                          
                          >= 6                          
                          =  a()                        
        
        activate(n__f(X)) =  8*X                        
                          >= 8*X                        
                          =  f(activate(X))             
        
                     f(X) =  X                          
                          >= X                          
                          =  n__f(X)                    
        
                f(f(a())) =  6                          
                          >= 0                          
                          =  c(n__f(n__g(n__f(n__a()))))
        
                     g(X) =  2 + X                      
                          >= 2 + X                      
                          =  n__g(X)                    
        
** Step 1.b:5: 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))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a,activate,f,g} and constructors {c,n__a,n__f,n__g}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

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