```* Step 1: Bounds WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict TRS:
activate(X) -> X
activate(n__d(X)) -> d(X)
activate(n__f(X)) -> f(activate(X))
activate(n__g(X)) -> g(X)
c(X) -> d(activate(X))
d(X) -> n__d(X)
f(X) -> n__f(X)
f(f(X)) -> c(n__f(n__g(n__f(X))))
g(X) -> n__g(X)
h(X) -> c(n__d(X))
- Signature:
{activate/1,c/1,d/1,f/1,g/1,h/1} / {n__d/1,n__f/1,n__g/1}
- Obligation:
runtime complexity wrt. defined symbols {activate,c,d,f,g,h} and constructors {n__d,n__f,n__g}
+ Applied Processor:
Bounds {initialAutomaton = perSymbol, enrichment = match}
+ Details:
The problem is match-bounded by 4.
The enriched problem is compatible with follwoing automaton.
activate_0(7) -> 1
activate_0(8) -> 1
activate_0(9) -> 1
activate_1(7) -> 10
activate_1(8) -> 10
activate_1(9) -> 10
activate_2(3) -> 11
activate_3(12) -> 14
activate_3(13) -> 15
c_0(7) -> 2
c_0(8) -> 2
c_0(9) -> 2
c_1(3) -> 6
c_2(12) -> 1
c_2(12) -> 10
d_0(7) -> 3
d_0(7) -> 11
d_0(8) -> 3
d_0(8) -> 11
d_0(9) -> 3
d_0(9) -> 11
d_1(7) -> 1
d_1(7) -> 10
d_1(8) -> 1
d_1(8) -> 10
d_1(9) -> 1
d_1(9) -> 10
d_1(10) -> 2
d_2(7) -> 11
d_2(8) -> 11
d_2(9) -> 11
d_2(11) -> 6
d_3(14) -> 1
d_3(14) -> 10
f_0(7) -> 4
f_0(8) -> 4
f_0(9) -> 4
f_1(10) -> 1
f_1(10) -> 10
f_3(15) -> 14
g_0(7) -> 5
g_0(8) -> 5
g_0(9) -> 5
g_1(7) -> 1
g_1(7) -> 10
g_1(8) -> 1
g_1(8) -> 10
g_1(9) -> 1
g_1(9) -> 10
g_3(10) -> 15
h_0(7) -> 6
h_0(8) -> 6
h_0(9) -> 6
n__d_0(7) -> 1
n__d_0(7) -> 7
n__d_0(7) -> 10
n__d_0(8) -> 1
n__d_0(8) -> 7
n__d_0(8) -> 10
n__d_0(9) -> 1
n__d_0(9) -> 7
n__d_0(9) -> 10
n__d_1(7) -> 3
n__d_1(7) -> 11
n__d_1(8) -> 3
n__d_1(8) -> 11
n__d_1(9) -> 3
n__d_1(9) -> 11
n__d_2(7) -> 1
n__d_2(7) -> 10
n__d_2(8) -> 1
n__d_2(8) -> 10
n__d_2(9) -> 1
n__d_2(9) -> 10
n__d_2(10) -> 2
n__d_3(7) -> 11
n__d_3(8) -> 11
n__d_3(9) -> 11
n__d_3(11) -> 6
n__d_4(14) -> 1
n__d_4(14) -> 10
n__f_0(7) -> 1
n__f_0(7) -> 8
n__f_0(7) -> 10
n__f_0(8) -> 1
n__f_0(8) -> 8
n__f_0(8) -> 10
n__f_0(9) -> 1
n__f_0(9) -> 8
n__f_0(9) -> 10
n__f_1(7) -> 4
n__f_1(8) -> 4
n__f_1(9) -> 4
n__f_2(10) -> 1
n__f_2(10) -> 10
n__f_2(13) -> 12
n__f_2(13) -> 14
n__f_4(15) -> 14
n__g_0(7) -> 1
n__g_0(7) -> 9
n__g_0(7) -> 10
n__g_0(8) -> 1
n__g_0(8) -> 9
n__g_0(8) -> 10
n__g_0(9) -> 1
n__g_0(9) -> 9
n__g_0(9) -> 10
n__g_1(7) -> 5
n__g_1(8) -> 5
n__g_1(9) -> 5
n__g_2(7) -> 1
n__g_2(7) -> 10
n__g_2(8) -> 1
n__g_2(8) -> 10
n__g_2(9) -> 1
n__g_2(9) -> 10
n__g_2(10) -> 13
n__g_2(10) -> 15
n__g_4(10) -> 15
3 -> 11
7 -> 1
7 -> 10
8 -> 1
8 -> 10
9 -> 1
9 -> 10
12 -> 14
13 -> 15
* Step 2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
activate(X) -> X
activate(n__d(X)) -> d(X)
activate(n__f(X)) -> f(activate(X))
activate(n__g(X)) -> g(X)
c(X) -> d(activate(X))
d(X) -> n__d(X)
f(X) -> n__f(X)
f(f(X)) -> c(n__f(n__g(n__f(X))))
g(X) -> n__g(X)
h(X) -> c(n__d(X))
- Signature:
{activate/1,c/1,d/1,f/1,g/1,h/1} / {n__d/1,n__f/1,n__g/1}
- Obligation:
runtime complexity wrt. defined symbols {activate,c,d,f,g,h} and constructors {n__d,n__f,n__g}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))
```