/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(7 + 3 * Arg_0, 13) + max(6, 3 * Arg_0) * nat(Arg_0) + nat(Arg_0 * max(6, 3 * Arg_0)) * nat(Arg_0) + nat(Arg_0 * max(6, 3 * Arg_0)) + nat(8 * Arg_0) + max(3, 3 + Arg_0) + max(8, 4 * Arg_0)). (0) CpxIntTrs (1) Loat Proof [FINISHED, 1882 ms] (2) BOUNDS(n^1, INF) ---------------------------------------- (0) Obligation: Complexity Int TRS consisting of the following rules: eval_perfect_start(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb0_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_bb0_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_0(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_0(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_1(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_1(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb6_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_x <= 1 eval_perfect_1(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb1_in(v__y3_0, v_1, v_6, v_x, v_x, v_y2_1, v_x)) :|: v_x > 1 eval_perfect_bb1_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb2_in(v__y3_0, v_y1_0_sink - 1, v_6, v_x, v_y1_0_sink, v_x, v_y3_0)) :|: v_y1_0_sink - 1 > 0 eval_perfect_bb1_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb5_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y1_0_sink - 1 <= 0 eval_perfect_bb2_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb3_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y2_1 >= v_1 eval_perfect_bb2_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb4_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y2_1 < v_1 eval_perfect_bb3_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb2_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1 - v_1, v_y3_0)) :|: TRUE eval_perfect_bb4_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_7(v__y3_0, v_1, v_y3_0 - v_1, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_7(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_8(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_8(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_9(v_6, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y2_1 >= 0 && v_y2_1 <= 0 eval_perfect_8(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_9(v_y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y2_1 < 0 eval_perfect_8(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_9(v_y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y2_1 > 0 eval_perfect_9(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_10(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_10(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_11(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE eval_perfect_11(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb1_in(v__y3_0, v_1, v_6, v_x, v_1, v_y2_1, v__y3_0)) :|: TRUE eval_perfect_bb5_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb6_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y3_0 < 0 eval_perfect_bb5_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb6_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y3_0 > 0 eval_perfect_bb5_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_bb6_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: v_y3_0 >= 0 && v_y3_0 <= 0 eval_perfect_bb6_in(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0) -> Com_1(eval_perfect_stop(v__y3_0, v_1, v_6, v_x, v_y1_0_sink, v_y2_1, v_y3_0)) :|: TRUE The start-symbols are:[eval_perfect_start_7] ---------------------------------------- (1) Loat Proof (FINISHED) ### Pre-processing the ITS problem ### Initial linear ITS problem Start location: evalperfectstart 0: evalperfectstart -> evalperfectbb0in : [], cost: 1 1: evalperfectbb0in -> evalperfect0 : [], cost: 1 2: evalperfect0 -> evalperfect1 : [], cost: 1 3: evalperfect1 -> evalperfectbb6in : [ 1>=A ], cost: 1 4: evalperfect1 -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 1 5: evalperfectbb1in -> evalperfectbb2in : D'=-1+B, E'=A, [ B>=2 ], cost: 1 6: evalperfectbb1in -> evalperfectbb5in : [ 1>=B ], cost: 1 7: evalperfectbb2in -> evalperfectbb3in : [ E>=D ], cost: 1 8: evalperfectbb2in -> evalperfectbb4in : [ D>=1+E ], cost: 1 9: evalperfectbb3in -> evalperfectbb2in : E'=-D+E, [], cost: 1 10: evalperfectbb4in -> evalperfect7 : F'=C-D, [], cost: 1 11: evalperfect7 -> evalperfect8 : [], cost: 1 12: evalperfect8 -> evalperfect9 : G'=F, [ E==0 ], cost: 1 13: evalperfect8 -> evalperfect9 : G'=C, [ 0>=1+E ], cost: 1 14: evalperfect8 -> evalperfect9 : G'=C, [ E>=1 ], cost: 1 15: evalperfect9 -> evalperfect10 : [], cost: 1 16: evalperfect10 -> evalperfect11 : [], cost: 1 17: evalperfect11 -> evalperfectbb1in : B'=D, C'=G, [], cost: 1 18: evalperfectbb5in -> evalperfectbb6in : [ 0>=1+C ], cost: 1 19: evalperfectbb5in -> evalperfectbb6in : [ C>=1 ], cost: 1 20: evalperfectbb5in -> evalperfectbb6in : [ C==0 ], cost: 1 21: evalperfectbb6in -> evalperfectstop : [], cost: 1 Removed unreachable and leaf rules: Start location: evalperfectstart 0: evalperfectstart -> evalperfectbb0in : [], cost: 1 1: evalperfectbb0in -> evalperfect0 : [], cost: 1 2: evalperfect0 -> evalperfect1 : [], cost: 1 4: evalperfect1 -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 1 5: evalperfectbb1in -> evalperfectbb2in : D'=-1+B, E'=A, [ B>=2 ], cost: 1 7: evalperfectbb2in -> evalperfectbb3in : [ E>=D ], cost: 1 8: evalperfectbb2in -> evalperfectbb4in : [ D>=1+E ], cost: 1 9: evalperfectbb3in -> evalperfectbb2in : E'=-D+E, [], cost: 1 10: evalperfectbb4in -> evalperfect7 : F'=C-D, [], cost: 1 11: evalperfect7 -> evalperfect8 : [], cost: 1 12: evalperfect8 -> evalperfect9 : G'=F, [ E==0 ], cost: 1 13: evalperfect8 -> evalperfect9 : G'=C, [ 0>=1+E ], cost: 1 14: evalperfect8 -> evalperfect9 : G'=C, [ E>=1 ], cost: 1 15: evalperfect9 -> evalperfect10 : [], cost: 1 16: evalperfect10 -> evalperfect11 : [], cost: 1 17: evalperfect11 -> evalperfectbb1in : B'=D, C'=G, [], cost: 1 ### Simplification by acceleration and chaining ### Eliminated locations (on linear paths): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 5: evalperfectbb1in -> evalperfectbb2in : D'=-1+B, E'=A, [ B>=2 ], cost: 1 25: evalperfectbb2in -> evalperfectbb2in : E'=-D+E, [ E>=D ], cost: 2 27: evalperfectbb2in -> evalperfect8 : F'=C-D, [ D>=1+E ], cost: 3 12: evalperfect8 -> evalperfect9 : G'=F, [ E==0 ], cost: 1 13: evalperfect8 -> evalperfect9 : G'=C, [ 0>=1+E ], cost: 1 14: evalperfect8 -> evalperfect9 : G'=C, [ E>=1 ], cost: 1 29: evalperfect9 -> evalperfectbb1in : B'=D, C'=G, [], cost: 3 Accelerating simple loops of location 5. Accelerating the following rules: 25: evalperfectbb2in -> evalperfectbb2in : E'=-D+E, [ E>=D ], cost: 2 Found no metering function for rule 25. Removing the simple loops:. Accelerated all simple loops using metering functions (where possible): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 5: evalperfectbb1in -> evalperfectbb2in : D'=-1+B, E'=A, [ B>=2 ], cost: 1 25: evalperfectbb2in -> evalperfectbb2in : E'=-D+E, [ E>=D ], cost: 2 27: evalperfectbb2in -> evalperfect8 : F'=C-D, [ D>=1+E ], cost: 3 12: evalperfect8 -> evalperfect9 : G'=F, [ E==0 ], cost: 1 13: evalperfect8 -> evalperfect9 : G'=C, [ 0>=1+E ], cost: 1 14: evalperfect8 -> evalperfect9 : G'=C, [ E>=1 ], cost: 1 29: evalperfect9 -> evalperfectbb1in : B'=D, C'=G, [], cost: 3 Chained accelerated rules (with incoming rules): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 5: evalperfectbb1in -> evalperfectbb2in : D'=-1+B, E'=A, [ B>=2 ], cost: 1 30: evalperfectbb1in -> evalperfectbb2in : D'=-1+B, E'=1+A-B, [ B>=2 && A>=-1+B ], cost: 3 27: evalperfectbb2in -> evalperfect8 : F'=C-D, [ D>=1+E ], cost: 3 12: evalperfect8 -> evalperfect9 : G'=F, [ E==0 ], cost: 1 13: evalperfect8 -> evalperfect9 : G'=C, [ 0>=1+E ], cost: 1 14: evalperfect8 -> evalperfect9 : G'=C, [ E>=1 ], cost: 1 29: evalperfect9 -> evalperfectbb1in : B'=D, C'=G, [], cost: 3 Eliminated locations (on tree-shaped paths): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 31: evalperfectbb1in -> evalperfect8 : D'=-1+B, E'=A, F'=1+C-B, [ B>=2 && -1+B>=1+A ], cost: 4 32: evalperfectbb1in -> evalperfect8 : D'=-1+B, E'=1+A-B, F'=1+C-B, [ B>=2 && A>=-1+B && -1+B>=2+A-B ], cost: 6 33: evalperfect8 -> evalperfectbb1in : B'=D, C'=F, G'=F, [ E==0 ], cost: 4 34: evalperfect8 -> evalperfectbb1in : B'=D, C'=C, G'=C, [ 0>=1+E ], cost: 4 35: evalperfect8 -> evalperfectbb1in : B'=D, C'=C, G'=C, [ E>=1 ], cost: 4 Eliminated locations (on tree-shaped paths): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 36: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=1+C-B, D'=-1+B, E'=A, F'=1+C-B, G'=1+C-B, [ B>=2 && -1+B>=1+A && A==0 ], cost: 8 37: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=C, D'=-1+B, E'=A, F'=1+C-B, G'=C, [ B>=2 && -1+B>=1+A && 0>=1+A ], cost: 8 38: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=C, D'=-1+B, E'=A, F'=1+C-B, G'=C, [ B>=2 && -1+B>=1+A && A>=1 ], cost: 8 39: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=1+C-B, D'=-1+B, E'=1+A-B, F'=1+C-B, G'=1+C-B, [ B>=2 && -1+B>=2+A-B && 1+A-B==0 ], cost: 10 40: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=C, D'=-1+B, E'=1+A-B, F'=1+C-B, G'=C, [ B>=2 && -1+B>=2+A-B && 1+A-B>=1 ], cost: 10 Accelerating simple loops of location 4. Simplified some of the simple loops (and removed duplicate rules). Accelerating the following rules: 36: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=1+C-B, D'=-1+B, E'=A, F'=1+C-B, G'=1+C-B, [ B>=2 && -1+B>=1+A && A==0 ], cost: 8 37: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, D'=-1+B, E'=A, F'=1+C-B, G'=C, [ B>=2 && -1+B>=1+A && 0>=1+A ], cost: 8 38: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, D'=-1+B, E'=A, F'=1+C-B, G'=C, [ B>=2 && -1+B>=1+A && A>=1 ], cost: 8 39: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, C'=1+C-B, D'=-1+B, E'=1+A-B, F'=1+C-B, G'=1+C-B, [ B>=2 && -1+B>=2+A-B && 1+A-B==0 ], cost: 10 40: evalperfectbb1in -> evalperfectbb1in : B'=-1+B, D'=-1+B, E'=1+A-B, F'=1+C-B, G'=C, [ B>=2 && -1+B>=2+A-B && 1+A-B>=1 ], cost: 10 Accelerated rule 36 with metering function -1-A+B, yielding the new rule 41. Accelerated rule 37 with metering function -1+B, yielding the new rule 42. Accelerated rule 38 with metering function -1-A+B, yielding the new rule 43. Accelerated rule 39 with metering function -1-A+B, yielding the new rule 44. Accelerated rule 40 with metering function meter (where 2*meter==-2-A+2*B), yielding the new rule 45. During metering: Instantiating temporary variables by {meter==1} Removing the simple loops: 36 37 38 39 40. Accelerated all simple loops using metering functions (where possible): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 41: evalperfectbb1in -> evalperfectbb1in : B'=1+A, C'=-5/2+C+1/2*(1+A-B)^2-3/2*A+(1+A-B)*B+3/2*B, D'=1+A, E'=A, F'=-7/2+C+1/2*(1+A-B)^2-3/2*A+(1+A-B)*B+3/2*B, G'=-7/2+C+1/2*(1+A-B)^2-3/2*A+(1+A-B)*B+3/2*B, [ B>=2 && -1+B>=1+A && A==0 ], cost: -8-8*A+8*B 42: evalperfectbb1in -> evalperfectbb1in : B'=1, D'=1, E'=A, F'=-1+C, G'=C, [ B>=2 && -1+B>=1+A && 0>=1+A ], cost: -8+8*B 43: evalperfectbb1in -> evalperfectbb1in : B'=1+A, D'=1+A, E'=A, F'=-1+C-A, G'=C, [ B>=2 && -1+B>=1+A && A>=1 ], cost: -8-8*A+8*B 44: evalperfectbb1in -> evalperfectbb1in : B'=1+A, C'=-5/2+C+1/2*(1+A-B)^2-3/2*A+(1+A-B)*B+3/2*B, D'=1+A, E'=-1, F'=-7/2+C+1/2*(1+A-B)^2-3/2*A+(1+A-B)*B+3/2*B, G'=-7/2+C+1/2*(1+A-B)^2-3/2*A+(1+A-B)*B+3/2*B, [ B>=2 && -1+B>=2+A-B && 1+A-B==0 && -1-A+B>=1 ], cost: -10-10*A+10*B 45: evalperfectbb1in -> evalperfectbb1in : B'=-meter+B, D'=-meter+B, E'=meter+A-B, F'=meter+C-B, G'=C, [ B>=2 && -1+B>=2+A-B && 1+A-B>=1 && 2*meter==-2-A+2*B && meter>=1 ], cost: 10*meter Chained accelerated rules (with incoming rules): Start location: evalperfectstart 24: evalperfectstart -> evalperfectbb1in : B'=A, C'=A, [ A>=2 ], cost: 4 46: evalperfectstart -> evalperfectbb1in : B'=-meter+A, C'=A, D'=-meter+A, E'=meter, F'=meter, G'=A, [ -1+A>=2 && 2*meter==-2+A && meter>=1 ], cost: 4+10*meter Removed unreachable locations (and leaf rules with constant cost): Start location: evalperfectstart 46: evalperfectstart -> evalperfectbb1in : B'=-meter+A, C'=A, D'=-meter+A, E'=meter, F'=meter, G'=A, [ -1+A>=2 && 2*meter==-2+A && meter>=1 ], cost: 4+10*meter ### Computing asymptotic complexity ### Fully simplified ITS problem Start location: evalperfectstart 46: evalperfectstart -> evalperfectbb1in : B'=-meter+A, C'=A, D'=-meter+A, E'=meter, F'=meter, G'=A, [ -1+A>=2 && 2*meter==-2+A && meter>=1 ], cost: 4+10*meter Computing asymptotic complexity for rule 46 Solved the limit problem by the following transformations: Created initial limit problem: 3+2*meter-A (+/+!), -1-2*meter+A (+/+!), -2+A (+/+!), 4+10*meter (+) [not solved] applying transformation rule (C) using substitution {A==2+2*meter} resulting limit problem: 1 (+/+!), 2*meter (+/+!), 4+10*meter (+) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 2*meter (+/+!), 4+10*meter (+) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {meter==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 3+2*meter-A (+/+!), -1-2*meter+A (+/+!), -2+A (+/+!), 4+10*meter (+) [not solved] applying transformation rule (C) using substitution {A==2+2*meter} resulting limit problem: 1 (+/+!), 2*meter (+/+!), 4+10*meter (+) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 2*meter (+/+!), 4+10*meter (+) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {meter==n} resulting limit problem: [solved] Solution: meter / n A / 2+2*n Resulting cost 4+10*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: 4+10*n Rule cost: 4+10*meter Rule guard: [ -1+A>=2 && 2*meter==-2+A ] WORST_CASE(Omega(n^1),?) ---------------------------------------- (2) BOUNDS(n^1, INF)