/export/starexec/sandbox2/solver/bin/starexec_run_complexity /export/starexec/sandbox2/benchmark/theBenchmark.koat /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- MAYBE proof of /export/starexec/sandbox2/benchmark/theBenchmark.koat # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty The runtime complexity of the given CpxIntTrs could be proven to be BOUNDS(1, INF). (0) CpxIntTrs (1) Loat Proof [FINISHED, 611 ms] (2) BOUNDS(1, INF) ---------------------------------------- (0) Obligation: Complexity Int TRS consisting of the following rules: eval_speedFails4_start(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_bb0_in(v__, v__0, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_bb0_in(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_1(v__, v__0, nondef_0, v_n, v_x)) :|: TRUE eval_speedFails4_1(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_2(v__, v__0, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_2(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_3(v__, v__0, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_3(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_4(v__, v__0, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_4(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_5(1, v__0, v_0, v_n, v_x)) :|: v_0 >= 1 eval_speedFails4_4(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_5(-(1), v__0, v_0, v_n, v_x)) :|: v_0 < 1 eval_speedFails4_5(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_6(v__, v__0, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_6(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_7(v__, v__0, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_7(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_bb1_in(v__, v_x, v_0, v_n, v_x)) :|: TRUE eval_speedFails4_bb1_in(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_bb2_in(v__, v__0, v_0, v_n, v_x)) :|: v__0 <= v_n eval_speedFails4_bb1_in(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_bb3_in(v__, v__0, v_0, v_n, v_x)) :|: v__0 > v_n eval_speedFails4_bb2_in(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_bb1_in(v__, v__0 + v__, v_0, v_n, v_x)) :|: v_0 >= 1 eval_speedFails4_bb2_in(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_bb1_in(v__, v__0 - v__, v_0, v_n, v_x)) :|: v_0 < 1 eval_speedFails4_bb3_in(v__, v__0, v_0, v_n, v_x) -> Com_1(eval_speedFails4_stop(v__, v__0, v_0, v_n, v_x)) :|: TRUE The start-symbols are:[eval_speedFails4_start_5] ---------------------------------------- (1) Loat Proof (FINISHED) ### Pre-processing the ITS problem ### Initial linear ITS problem Start location: evalspeedFails4start 0: evalspeedFails4start -> evalspeedFails4bb0in : [], cost: 1 1: evalspeedFails4bb0in -> evalspeedFails41 : A'=free, [], cost: 1 2: evalspeedFails41 -> evalspeedFails42 : [], cost: 1 3: evalspeedFails42 -> evalspeedFails43 : [], cost: 1 4: evalspeedFails43 -> evalspeedFails44 : [], cost: 1 5: evalspeedFails44 -> evalspeedFails45 : B'=1, [ A>=1 ], cost: 1 6: evalspeedFails44 -> evalspeedFails45 : B'=-1, [ 0>=A ], cost: 1 7: evalspeedFails45 -> evalspeedFails46 : [], cost: 1 8: evalspeedFails46 -> evalspeedFails47 : [], cost: 1 9: evalspeedFails47 -> evalspeedFails4bb1in : C'=D, [], cost: 1 10: evalspeedFails4bb1in -> evalspeedFails4bb2in : [ E>=C ], cost: 1 11: evalspeedFails4bb1in -> evalspeedFails4bb3in : [ C>=1+E ], cost: 1 12: evalspeedFails4bb2in -> evalspeedFails4bb1in : C'=C+B, [ A>=1 ], cost: 1 13: evalspeedFails4bb2in -> evalspeedFails4bb1in : C'=C-B, [ 0>=A ], cost: 1 14: evalspeedFails4bb3in -> evalspeedFails4stop : [], cost: 1 Checking for constant complexity: The following rule is satisfiable with cost >= 1, yielding constant complexity: 0: evalspeedFails4start -> evalspeedFails4bb0in : [], cost: 1 Removed unreachable and leaf rules: Start location: evalspeedFails4start 0: evalspeedFails4start -> evalspeedFails4bb0in : [], cost: 1 1: evalspeedFails4bb0in -> evalspeedFails41 : A'=free, [], cost: 1 2: evalspeedFails41 -> evalspeedFails42 : [], cost: 1 3: evalspeedFails42 -> evalspeedFails43 : [], cost: 1 4: evalspeedFails43 -> evalspeedFails44 : [], cost: 1 5: evalspeedFails44 -> evalspeedFails45 : B'=1, [ A>=1 ], cost: 1 6: evalspeedFails44 -> evalspeedFails45 : B'=-1, [ 0>=A ], cost: 1 7: evalspeedFails45 -> evalspeedFails46 : [], cost: 1 8: evalspeedFails46 -> evalspeedFails47 : [], cost: 1 9: evalspeedFails47 -> evalspeedFails4bb1in : C'=D, [], cost: 1 10: evalspeedFails4bb1in -> evalspeedFails4bb2in : [ E>=C ], cost: 1 12: evalspeedFails4bb2in -> evalspeedFails4bb1in : C'=C+B, [ A>=1 ], cost: 1 13: evalspeedFails4bb2in -> evalspeedFails4bb1in : C'=C-B, [ 0>=A ], cost: 1 ### Simplification by acceleration and chaining ### Eliminated locations (on linear paths): Start location: evalspeedFails4start 18: evalspeedFails4start -> evalspeedFails44 : A'=free, [], cost: 5 5: evalspeedFails44 -> evalspeedFails45 : B'=1, [ A>=1 ], cost: 1 6: evalspeedFails44 -> evalspeedFails45 : B'=-1, [ 0>=A ], cost: 1 20: evalspeedFails45 -> evalspeedFails4bb1in : C'=D, [], cost: 3 10: evalspeedFails4bb1in -> evalspeedFails4bb2in : [ E>=C ], cost: 1 12: evalspeedFails4bb2in -> evalspeedFails4bb1in : C'=C+B, [ A>=1 ], cost: 1 13: evalspeedFails4bb2in -> evalspeedFails4bb1in : C'=C-B, [ 0>=A ], cost: 1 Eliminated locations (on tree-shaped paths): Start location: evalspeedFails4start 21: evalspeedFails4start -> evalspeedFails45 : A'=free, B'=1, [ free>=1 ], cost: 6 22: evalspeedFails4start -> evalspeedFails45 : A'=free, B'=-1, [ 0>=free ], cost: 6 20: evalspeedFails45 -> evalspeedFails4bb1in : C'=D, [], cost: 3 23: evalspeedFails4bb1in -> evalspeedFails4bb1in : C'=C+B, [ E>=C && A>=1 ], cost: 2 24: evalspeedFails4bb1in -> evalspeedFails4bb1in : C'=C-B, [ E>=C && 0>=A ], cost: 2 Accelerating simple loops of location 9. Accelerating the following rules: 23: evalspeedFails4bb1in -> evalspeedFails4bb1in : C'=C+B, [ E>=C && A>=1 ], cost: 2 24: evalspeedFails4bb1in -> evalspeedFails4bb1in : C'=C-B, [ E>=C && 0>=A ], cost: 2 Found no metering function for rule 23. Found no metering function for rule 24. Removing the simple loops:. Accelerated all simple loops using metering functions (where possible): Start location: evalspeedFails4start 21: evalspeedFails4start -> evalspeedFails45 : A'=free, B'=1, [ free>=1 ], cost: 6 22: evalspeedFails4start -> evalspeedFails45 : A'=free, B'=-1, [ 0>=free ], cost: 6 20: evalspeedFails45 -> evalspeedFails4bb1in : C'=D, [], cost: 3 23: evalspeedFails4bb1in -> evalspeedFails4bb1in : C'=C+B, [ E>=C && A>=1 ], cost: 2 24: evalspeedFails4bb1in -> evalspeedFails4bb1in : C'=C-B, [ E>=C && 0>=A ], cost: 2 Chained accelerated rules (with incoming rules): Start location: evalspeedFails4start 21: evalspeedFails4start -> evalspeedFails45 : A'=free, B'=1, [ free>=1 ], cost: 6 22: evalspeedFails4start -> evalspeedFails45 : A'=free, B'=-1, [ 0>=free ], cost: 6 20: evalspeedFails45 -> evalspeedFails4bb1in : C'=D, [], cost: 3 25: evalspeedFails45 -> evalspeedFails4bb1in : C'=D+B, [ E>=D && A>=1 ], cost: 5 26: evalspeedFails45 -> evalspeedFails4bb1in : C'=D-B, [ E>=D && 0>=A ], cost: 5 Removed unreachable locations (and leaf rules with constant cost): Start location: evalspeedFails4start ### Computing asymptotic complexity ### Fully simplified ITS problem Start location: evalspeedFails4start Obtained the following overall complexity (w.r.t. the length of the input n): Complexity: Constant Cpx degree: 0 Solved cost: 1 Rule cost: 1 Rule guard: [] WORST_CASE(Omega(1),?) ---------------------------------------- (2) BOUNDS(1, INF)