/export/starexec/sandbox2/solver/bin/starexec_run_complexity /export/starexec/sandbox2/benchmark/theBenchmark.koat /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), O(n^2)) proof of /export/starexec/sandbox2/benchmark/theBenchmark.koat # AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty The runtime complexity of the given CpxIntTrs could be proven to be BOUNDS(n^1, max(10 + 2 * Arg_2, 10) + nat(Arg_2^2) + nat(4 * Arg_2) + max(2, 2 + Arg_2) + nat(1 + 4 * Arg_2) + nat(Arg_2^2) * nat(Arg_2) + nat(Arg_2)^2). (0) CpxIntTrs (1) Loat Proof [FINISHED, 1118 ms] (2) BOUNDS(n^1, INF) ---------------------------------------- (0) Obligation: Complexity Int TRS consisting of the following rules: eval_foo_start(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb0_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_bb0_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_0(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_0(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_1(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_1(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_2(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_2(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_3(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_3(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_4(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_4(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_5(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_5(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_6(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_6(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_7(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_7(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb1_in(v_1, v_2, v_3, v_n, v_p_0, 0, v_n)) :|: TRUE eval_foo_bb1_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb2_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: v_x_0 > 0 eval_foo_bb1_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb5_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: v_x_0 <= 0 eval_foo_bb2_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_10(v_x_0 - 1, v_r_0 + 1, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_10(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_11(v_1, v_2, nondef_0, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE eval_foo_11(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb3_in(v_1, v_2, v_3, v_n, v_2, v_r_0, v_x_0)) :|: v_3 > 0 eval_foo_11(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb1_in(v_1, v_2, v_3, v_n, v_p_0, v_2, v_1)) :|: v_3 <= 0 eval_foo_bb3_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb4_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: v_p_0 > 0 eval_foo_bb3_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb1_in(v_1, v_2, v_3, v_n, v_p_0, 0, v_1)) :|: v_p_0 <= 0 eval_foo_bb4_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_bb3_in(v_1, v_2, v_3, v_n, v_p_0 - 1, v_r_0, v_x_0)) :|: TRUE eval_foo_bb5_in(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0) -> Com_1(eval_foo_stop(v_1, v_2, v_3, v_n, v_p_0, v_r_0, v_x_0)) :|: TRUE The start-symbols are:[eval_foo_start_7] ---------------------------------------- (1) Loat Proof (FINISHED) ### Pre-processing the ITS problem ### Initial linear ITS problem Start location: evalfoostart 0: evalfoostart -> evalfoobb0in : [], cost: 1 1: evalfoobb0in -> evalfoo0 : [], cost: 1 2: evalfoo0 -> evalfoo1 : [], cost: 1 3: evalfoo1 -> evalfoo2 : [], cost: 1 4: evalfoo2 -> evalfoo3 : [], cost: 1 5: evalfoo3 -> evalfoo4 : [], cost: 1 6: evalfoo4 -> evalfoo5 : [], cost: 1 7: evalfoo5 -> evalfoo6 : [], cost: 1 8: evalfoo6 -> evalfoo7 : [], cost: 1 9: evalfoo7 -> evalfoobb1in : A'=0, B'=C, [], cost: 1 10: evalfoobb1in -> evalfoobb2in : [ B>=1 ], cost: 1 11: evalfoobb1in -> evalfoobb5in : [ 0>=B ], cost: 1 12: evalfoobb2in -> evalfoo10 : D'=-1+B, E'=1+A, [], cost: 1 13: evalfoo10 -> evalfoo11 : F'=free, [], cost: 1 14: evalfoo11 -> evalfoobb3in : G'=E, [ F>=1 ], cost: 1 15: evalfoo11 -> evalfoobb1in : A'=E, B'=D, [ 0>=F ], cost: 1 16: evalfoobb3in -> evalfoobb4in : [ G>=1 ], cost: 1 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 18: evalfoobb4in -> evalfoobb3in : G'=-1+G, [], cost: 1 19: evalfoobb5in -> evalfoostop : [], cost: 1 Removed unreachable and leaf rules: Start location: evalfoostart 0: evalfoostart -> evalfoobb0in : [], cost: 1 1: evalfoobb0in -> evalfoo0 : [], cost: 1 2: evalfoo0 -> evalfoo1 : [], cost: 1 3: evalfoo1 -> evalfoo2 : [], cost: 1 4: evalfoo2 -> evalfoo3 : [], cost: 1 5: evalfoo3 -> evalfoo4 : [], cost: 1 6: evalfoo4 -> evalfoo5 : [], cost: 1 7: evalfoo5 -> evalfoo6 : [], cost: 1 8: evalfoo6 -> evalfoo7 : [], cost: 1 9: evalfoo7 -> evalfoobb1in : A'=0, B'=C, [], cost: 1 10: evalfoobb1in -> evalfoobb2in : [ B>=1 ], cost: 1 12: evalfoobb2in -> evalfoo10 : D'=-1+B, E'=1+A, [], cost: 1 13: evalfoo10 -> evalfoo11 : F'=free, [], cost: 1 14: evalfoo11 -> evalfoobb3in : G'=E, [ F>=1 ], cost: 1 15: evalfoo11 -> evalfoobb1in : A'=E, B'=D, [ 0>=F ], cost: 1 16: evalfoobb3in -> evalfoobb4in : [ G>=1 ], cost: 1 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 18: evalfoobb4in -> evalfoobb3in : G'=-1+G, [], cost: 1 ### Simplification by acceleration and chaining ### Eliminated locations (on linear paths): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 30: evalfoobb1in -> evalfoo11 : D'=-1+B, E'=1+A, F'=free, [ B>=1 ], cost: 3 14: evalfoo11 -> evalfoobb3in : G'=E, [ F>=1 ], cost: 1 15: evalfoo11 -> evalfoobb1in : A'=E, B'=D, [ 0>=F ], cost: 1 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 31: evalfoobb3in -> evalfoobb3in : G'=-1+G, [ G>=1 ], cost: 2 Accelerating simple loops of location 14. Accelerating the following rules: 31: evalfoobb3in -> evalfoobb3in : G'=-1+G, [ G>=1 ], cost: 2 Accelerated rule 31 with metering function G, yielding the new rule 32. Removing the simple loops: 31. Accelerated all simple loops using metering functions (where possible): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 30: evalfoobb1in -> evalfoo11 : D'=-1+B, E'=1+A, F'=free, [ B>=1 ], cost: 3 14: evalfoo11 -> evalfoobb3in : G'=E, [ F>=1 ], cost: 1 15: evalfoo11 -> evalfoobb1in : A'=E, B'=D, [ 0>=F ], cost: 1 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 32: evalfoobb3in -> evalfoobb3in : G'=0, [ G>=1 ], cost: 2*G Chained accelerated rules (with incoming rules): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 30: evalfoobb1in -> evalfoo11 : D'=-1+B, E'=1+A, F'=free, [ B>=1 ], cost: 3 14: evalfoo11 -> evalfoobb3in : G'=E, [ F>=1 ], cost: 1 15: evalfoo11 -> evalfoobb1in : A'=E, B'=D, [ 0>=F ], cost: 1 33: evalfoo11 -> evalfoobb3in : G'=0, [ F>=1 && E>=1 ], cost: 1+2*E 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 Eliminated locations (on tree-shaped paths): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 34: evalfoobb1in -> evalfoobb3in : D'=-1+B, E'=1+A, F'=free, G'=1+A, [ B>=1 && free>=1 ], cost: 4 35: evalfoobb1in -> evalfoobb1in : A'=1+A, B'=-1+B, D'=-1+B, E'=1+A, F'=free, [ B>=1 && 0>=free ], cost: 4 36: evalfoobb1in -> evalfoobb3in : D'=-1+B, E'=1+A, F'=free, G'=0, [ B>=1 && free>=1 && 1+A>=1 ], cost: 6+2*A 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 Accelerating simple loops of location 10. Accelerating the following rules: 35: evalfoobb1in -> evalfoobb1in : A'=1+A, B'=-1+B, D'=-1+B, E'=1+A, F'=free, [ B>=1 && 0>=free ], cost: 4 Accelerated rule 35 with metering function B, yielding the new rule 37. Removing the simple loops: 35. Accelerated all simple loops using metering functions (where possible): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 34: evalfoobb1in -> evalfoobb3in : D'=-1+B, E'=1+A, F'=free, G'=1+A, [ B>=1 && free>=1 ], cost: 4 36: evalfoobb1in -> evalfoobb3in : D'=-1+B, E'=1+A, F'=free, G'=0, [ B>=1 && free>=1 && 1+A>=1 ], cost: 6+2*A 37: evalfoobb1in -> evalfoobb1in : A'=A+B, B'=0, D'=0, E'=A+B, F'=free, [ B>=1 && 0>=free ], cost: 4*B 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 Chained accelerated rules (with incoming rules): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 39: evalfoostart -> evalfoobb1in : A'=C, B'=0, D'=0, E'=C, F'=free, [ C>=1 && 0>=free ], cost: 10+4*C 34: evalfoobb1in -> evalfoobb3in : D'=-1+B, E'=1+A, F'=free, G'=1+A, [ B>=1 && free>=1 ], cost: 4 36: evalfoobb1in -> evalfoobb3in : D'=-1+B, E'=1+A, F'=free, G'=0, [ B>=1 && free>=1 && 1+A>=1 ], cost: 6+2*A 17: evalfoobb3in -> evalfoobb1in : A'=0, B'=D, [ 0>=G ], cost: 1 38: evalfoobb3in -> evalfoobb1in : A'=D, B'=0, D'=0, E'=D, F'=free, [ 0>=G && D>=1 && 0>=free ], cost: 1+4*D Eliminated locations (on tree-shaped paths): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 39: evalfoostart -> evalfoobb1in : A'=C, B'=0, D'=0, E'=C, F'=free, [ C>=1 && 0>=free ], cost: 10+4*C 40: evalfoobb1in -> evalfoobb1in : A'=0, B'=-1+B, D'=-1+B, E'=1+A, F'=free, G'=1+A, [ B>=1 && free>=1 && 0>=1+A ], cost: 5 41: evalfoobb1in -> evalfoobb1in : A'=0, B'=-1+B, D'=-1+B, E'=1+A, F'=free, G'=0, [ B>=1 && free>=1 && 1+A>=1 ], cost: 7+2*A 42: evalfoobb1in -> [20] : [ B>=1 && free>=1 && 1+A>=1 ], cost: 6+2*A Accelerating simple loops of location 10. Accelerating the following rules: 40: evalfoobb1in -> evalfoobb1in : A'=0, B'=-1+B, D'=-1+B, E'=1+A, F'=free, G'=1+A, [ B>=1 && free>=1 && 0>=1+A ], cost: 5 41: evalfoobb1in -> evalfoobb1in : A'=0, B'=-1+B, D'=-1+B, E'=1+A, F'=free, G'=0, [ B>=1 && free>=1 && 1+A>=1 ], cost: 7+2*A Found no metering function for rule 40. Accelerated rule 41 with metering function B, yielding the new rule 43. Removing the simple loops: 41. Accelerated all simple loops using metering functions (where possible): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 39: evalfoostart -> evalfoobb1in : A'=C, B'=0, D'=0, E'=C, F'=free, [ C>=1 && 0>=free ], cost: 10+4*C 40: evalfoobb1in -> evalfoobb1in : A'=0, B'=-1+B, D'=-1+B, E'=1+A, F'=free, G'=1+A, [ B>=1 && free>=1 && 0>=1+A ], cost: 5 42: evalfoobb1in -> [20] : [ B>=1 && free>=1 && 1+A>=1 ], cost: 6+2*A 43: evalfoobb1in -> evalfoobb1in : A'=0, B'=0, D'=0, E'=1, F'=free, G'=0, [ B>=1 && free>=1 && 1+A>=1 ], cost: 7*B Chained accelerated rules (with incoming rules): Start location: evalfoostart 28: evalfoostart -> evalfoobb1in : A'=0, B'=C, [], cost: 10 39: evalfoostart -> evalfoobb1in : A'=C, B'=0, D'=0, E'=C, F'=free, [ C>=1 && 0>=free ], cost: 10+4*C 44: evalfoostart -> evalfoobb1in : A'=0, B'=0, D'=0, E'=1, F'=free, G'=0, [ C>=1 && free>=1 ], cost: 10+7*C 42: evalfoobb1in -> [20] : [ B>=1 && free>=1 && 1+A>=1 ], cost: 6+2*A Eliminated locations (on tree-shaped paths): Start location: evalfoostart 45: evalfoostart -> [20] : A'=0, B'=C, [ C>=1 && free>=1 ], cost: 16 46: evalfoostart -> [22] : [ C>=1 && 0>=free ], cost: 10+4*C 47: evalfoostart -> [22] : [ C>=1 && free>=1 ], cost: 10+7*C Applied pruning (of leafs and parallel rules): Start location: evalfoostart 46: evalfoostart -> [22] : [ C>=1 && 0>=free ], cost: 10+4*C 47: evalfoostart -> [22] : [ C>=1 && free>=1 ], cost: 10+7*C ### Computing asymptotic complexity ### Fully simplified ITS problem Start location: evalfoostart 46: evalfoostart -> [22] : [ C>=1 && 0>=free ], cost: 10+4*C 47: evalfoostart -> [22] : [ C>=1 && free>=1 ], cost: 10+7*C Computing asymptotic complexity for rule 46 Solved the limit problem by the following transformations: Created initial limit problem: 1-free (+/+!), C (+/+!), 10+4*C (+) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free==0,C==n} resulting limit problem: [solved] Solution: free / 0 C / n Resulting cost 10+4*n has complexity: Poly(n^1) Found new complexity Poly(n^1). Obtained the following overall complexity (w.r.t. the length of the input n): Complexity: Poly(n^1) Cpx degree: 1 Solved cost: 10+4*n Rule cost: 10+4*C Rule guard: [ C>=1 && 0>=free ] WORST_CASE(Omega(n^1),?) ---------------------------------------- (2) BOUNDS(n^1, INF)