/export/starexec/sandbox/solver/bin/starexec_run_tct_rc /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1),O(n^1)) * Step 1: Sum. WORST_CASE(Omega(n^1),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: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 1.a:1: Sum. WORST_CASE(Omega(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: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 1.a:2: DecreasingLoops. WORST_CASE(Omega(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: 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: 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 1.b: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(Omega(n^1),O(n^1))