/export/starexec/sandbox/solver/bin/starexec_run_complexity /export/starexec/sandbox/benchmark/theBenchmark.koat /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), O(n^2)) proof of /export/starexec/sandbox/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(4, -2 + 3 * Arg_0) * nat(Arg_0) + max(4, -2 + 3 * Arg_0) * nat(Arg_0)^2 + max(2, -2 + 2 * Arg_0) + nat(-1 + Arg_0) + max(6, -6 + 6 * Arg_0) + max(7 + 3 * Arg_0, 13)). (0) CpxIntTrs (1) Loat Proof [FINISHED, 1627 ms] (2) BOUNDS(n^1, INF) ---------------------------------------- (0) Obligation: Complexity Int TRS consisting of the following rules: evalperfectstart(A, B, C, D) -> Com_1(evalperfectentryin(A, B, C, D)) :|: TRUE evalperfectentryin(A, B, C, D) -> Com_1(evalperfectreturnin(A, B, C, D)) :|: 1 >= A evalperfectentryin(A, B, C, D) -> Com_1(evalperfectbb1in(A, B, C, D)) :|: A >= 2 evalperfectbb1in(A, B, C, D) -> Com_1(evalperfectbb8in(A, A, A - 1, D)) :|: TRUE evalperfectbb8in(A, B, C, D) -> Com_1(evalperfectbb4in(A, B, C, A)) :|: C >= 1 evalperfectbb8in(A, B, C, D) -> Com_1(evalperfectbb9in(B, B, C, D)) :|: 0 >= C evalperfectbb4in(A, B, C, D) -> Com_1(evalperfectbb3in(A, B, C, D)) :|: D >= C evalperfectbb4in(A, B, C, D) -> Com_1(evalperfectbb5in(A, B, C, D)) :|: C >= D + 1 evalperfectbb3in(A, B, C, D) -> Com_1(evalperfectbb4in(A, B, C, D - C)) :|: TRUE evalperfectbb5in(A, B, C, D) -> Com_1(evalperfectbb8in(A, B - C, C - 1, D)) :|: D >= 0 && D <= 0 evalperfectbb5in(A, B, C, D) -> Com_1(evalperfectbb8in(A, B, C - 1, D)) :|: 0 >= D + 1 evalperfectbb5in(A, B, C, D) -> Com_1(evalperfectbb8in(A, B, C - 1, D)) :|: D >= 1 evalperfectbb9in(A, B, C, D) -> Com_1(evalperfectreturnin(A, B, C, D)) :|: 0 >= A + 1 evalperfectbb9in(A, B, C, D) -> Com_1(evalperfectreturnin(A, B, C, D)) :|: A >= 1 evalperfectbb9in(A, B, C, D) -> Com_1(evalperfectreturnin(A, B, C, D)) :|: A >= 0 && A <= 0 evalperfectreturnin(A, B, C, D) -> Com_1(evalperfectstop(A, B, C, D)) :|: TRUE The start-symbols are:[evalperfectstart_4] ---------------------------------------- (1) Loat Proof (FINISHED) ### Pre-processing the ITS problem ### Initial linear ITS problem Start location: evalperfectstart 0: evalperfectstart -> evalperfectentryin : [], cost: 1 1: evalperfectentryin -> evalperfectreturnin : [ 1>=A ], cost: 1 2: evalperfectentryin -> evalperfectbb1in : [ A>=2 ], cost: 1 3: evalperfectbb1in -> evalperfectbb8in : B'=A, C'=-1+A, [], cost: 1 4: evalperfectbb8in -> evalperfectbb4in : D'=A, [ C>=1 ], cost: 1 5: evalperfectbb8in -> evalperfectbb9in : A'=B, [ 0>=C ], cost: 1 6: evalperfectbb4in -> evalperfectbb3in : [ D>=C ], cost: 1 7: evalperfectbb4in -> evalperfectbb5in : [ C>=1+D ], cost: 1 8: evalperfectbb3in -> evalperfectbb4in : D'=-C+D, [], cost: 1 9: evalperfectbb5in -> evalperfectbb8in : B'=-C+B, C'=-1+C, [ D==0 ], cost: 1 10: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ 0>=1+D ], cost: 1 11: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ D>=1 ], cost: 1 12: evalperfectbb9in -> evalperfectreturnin : [ 0>=1+A ], cost: 1 13: evalperfectbb9in -> evalperfectreturnin : [ A>=1 ], cost: 1 14: evalperfectbb9in -> evalperfectreturnin : [ A==0 ], cost: 1 15: evalperfectreturnin -> evalperfectstop : [], cost: 1 Removed unreachable and leaf rules: Start location: evalperfectstart 0: evalperfectstart -> evalperfectentryin : [], cost: 1 2: evalperfectentryin -> evalperfectbb1in : [ A>=2 ], cost: 1 3: evalperfectbb1in -> evalperfectbb8in : B'=A, C'=-1+A, [], cost: 1 4: evalperfectbb8in -> evalperfectbb4in : D'=A, [ C>=1 ], cost: 1 6: evalperfectbb4in -> evalperfectbb3in : [ D>=C ], cost: 1 7: evalperfectbb4in -> evalperfectbb5in : [ C>=1+D ], cost: 1 8: evalperfectbb3in -> evalperfectbb4in : D'=-C+D, [], cost: 1 9: evalperfectbb5in -> evalperfectbb8in : B'=-C+B, C'=-1+C, [ D==0 ], cost: 1 10: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ 0>=1+D ], cost: 1 11: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ D>=1 ], cost: 1 ### Simplification by acceleration and chaining ### Eliminated locations (on linear paths): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 4: evalperfectbb8in -> evalperfectbb4in : D'=A, [ C>=1 ], cost: 1 7: evalperfectbb4in -> evalperfectbb5in : [ C>=1+D ], cost: 1 18: evalperfectbb4in -> evalperfectbb4in : D'=-C+D, [ D>=C ], cost: 2 9: evalperfectbb5in -> evalperfectbb8in : B'=-C+B, C'=-1+C, [ D==0 ], cost: 1 10: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ 0>=1+D ], cost: 1 11: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ D>=1 ], cost: 1 Accelerating simple loops of location 4. Accelerating the following rules: 18: evalperfectbb4in -> evalperfectbb4in : D'=-C+D, [ D>=C ], cost: 2 Found no metering function for rule 18. Removing the simple loops:. Accelerated all simple loops using metering functions (where possible): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 4: evalperfectbb8in -> evalperfectbb4in : D'=A, [ C>=1 ], cost: 1 7: evalperfectbb4in -> evalperfectbb5in : [ C>=1+D ], cost: 1 18: evalperfectbb4in -> evalperfectbb4in : D'=-C+D, [ D>=C ], cost: 2 9: evalperfectbb5in -> evalperfectbb8in : B'=-C+B, C'=-1+C, [ D==0 ], cost: 1 10: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ 0>=1+D ], cost: 1 11: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ D>=1 ], cost: 1 Chained accelerated rules (with incoming rules): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 4: evalperfectbb8in -> evalperfectbb4in : D'=A, [ C>=1 ], cost: 1 19: evalperfectbb8in -> evalperfectbb4in : D'=-C+A, [ C>=1 && A>=C ], cost: 3 7: evalperfectbb4in -> evalperfectbb5in : [ C>=1+D ], cost: 1 9: evalperfectbb5in -> evalperfectbb8in : B'=-C+B, C'=-1+C, [ D==0 ], cost: 1 10: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ 0>=1+D ], cost: 1 11: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ D>=1 ], cost: 1 Eliminated locations (on tree-shaped paths): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 20: evalperfectbb8in -> evalperfectbb5in : D'=A, [ C>=1 && C>=1+A ], cost: 2 21: evalperfectbb8in -> evalperfectbb5in : D'=-C+A, [ C>=1 && A>=C && C>=1-C+A ], cost: 4 9: evalperfectbb5in -> evalperfectbb8in : B'=-C+B, C'=-1+C, [ D==0 ], cost: 1 10: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ 0>=1+D ], cost: 1 11: evalperfectbb5in -> evalperfectbb8in : C'=-1+C, [ D>=1 ], cost: 1 Eliminated locations (on tree-shaped paths): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 22: evalperfectbb8in -> evalperfectbb8in : B'=-C+B, C'=-1+C, D'=A, [ C>=1 && C>=1+A && A==0 ], cost: 3 23: evalperfectbb8in -> evalperfectbb8in : C'=-1+C, D'=A, [ C>=1 && C>=1+A && 0>=1+A ], cost: 3 24: evalperfectbb8in -> evalperfectbb8in : C'=-1+C, D'=A, [ C>=1 && C>=1+A && A>=1 ], cost: 3 25: evalperfectbb8in -> evalperfectbb8in : B'=-C+B, C'=-1+C, D'=-C+A, [ C>=1 && C>=1-C+A && -C+A==0 ], cost: 5 26: evalperfectbb8in -> evalperfectbb8in : C'=-1+C, D'=-C+A, [ C>=1 && C>=1-C+A && -C+A>=1 ], cost: 5 Accelerating simple loops of location 3. Accelerating the following rules: 22: evalperfectbb8in -> evalperfectbb8in : B'=-C+B, C'=-1+C, D'=A, [ C>=1 && C>=1+A && A==0 ], cost: 3 23: evalperfectbb8in -> evalperfectbb8in : C'=-1+C, D'=A, [ C>=1 && C>=1+A && 0>=1+A ], cost: 3 24: evalperfectbb8in -> evalperfectbb8in : C'=-1+C, D'=A, [ C>=1 && C>=1+A && A>=1 ], cost: 3 25: evalperfectbb8in -> evalperfectbb8in : B'=-C+B, C'=-1+C, D'=-C+A, [ C>=1 && C>=1-C+A && -C+A==0 ], cost: 5 26: evalperfectbb8in -> evalperfectbb8in : C'=-1+C, D'=-C+A, [ C>=1 && C>=1-C+A && -C+A>=1 ], cost: 5 Accelerated rule 22 with metering function C-A, yielding the new rule 27. Accelerated rule 23 with metering function C, yielding the new rule 28. Accelerated rule 24 with metering function C-A, yielding the new rule 29. Accelerated rule 25 with metering function C-A, yielding the new rule 30. Accelerated rule 26 with metering function meter (where 2*meter==2*C-A), yielding the new rule 31. During metering: Instantiating temporary variables by {meter==1} Removing the simple loops: 22 23 24 25 26. Accelerated all simple loops using metering functions (where possible): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 27: evalperfectbb8in -> evalperfectbb8in : B'=-1-C*(C-A)+1/2*(C-A)^2+1/2*C-1/2*A+B, C'=A, D'=A, [ C>=1 && C>=1+A && A==0 ], cost: 3*C-3*A 28: evalperfectbb8in -> evalperfectbb8in : C'=0, D'=A, [ C>=1 && C>=1+A && 0>=1+A ], cost: 3*C 29: evalperfectbb8in -> evalperfectbb8in : C'=A, D'=A, [ C>=1 && C>=1+A && A>=1 ], cost: 3*C-3*A 30: evalperfectbb8in -> evalperfectbb8in : B'=-1-C*(C-A)+1/2*(C-A)^2+1/2*C-1/2*A+B, C'=A, D'=-1, [ C>=1 && C>=1-C+A && -C+A==0 && C-A>=1 ], cost: 5*C-5*A 31: evalperfectbb8in -> evalperfectbb8in : C'=C-meter, D'=-1-C+A+meter, [ C>=1 && C>=1-C+A && -C+A>=1 && 2*meter==2*C-A && meter>=1 ], cost: 5*meter Chained accelerated rules (with incoming rules): Start location: evalperfectstart 17: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A, [ A>=2 ], cost: 3 32: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A-meter, D'=meter, [ -1+A>=2 && 2*meter==-2+A && meter>=1 ], cost: 3+5*meter Removed unreachable locations (and leaf rules with constant cost): Start location: evalperfectstart 32: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A-meter, D'=meter, [ -1+A>=2 && 2*meter==-2+A && meter>=1 ], cost: 3+5*meter ### Computing asymptotic complexity ### Fully simplified ITS problem Start location: evalperfectstart 32: evalperfectstart -> evalperfectbb8in : B'=A, C'=-1+A-meter, D'=meter, [ -1+A>=2 && 2*meter==-2+A && meter>=1 ], cost: 3+5*meter Computing asymptotic complexity for rule 32 Solved the limit problem by the following transformations: Created initial limit problem: 3-A+2*meter (+/+!), 3+5*meter (+), -1+A-2*meter (+/+!), -2+A (+/+!) [not solved] applying transformation rule (C) using substitution {A==2+2*meter} resulting limit problem: 1 (+/+!), 3+5*meter (+), 2*meter (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 3+5*meter (+), 2*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-A+2*meter (+/+!), 3+5*meter (+), -1+A-2*meter (+/+!), -2+A (+/+!) [not solved] applying transformation rule (C) using substitution {A==2+2*meter} resulting limit problem: 1 (+/+!), 3+5*meter (+), 2*meter (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 3+5*meter (+), 2*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: A / 2+2*n meter / n Resulting cost 3+5*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: 3+5*n Rule cost: 3+5*meter Rule guard: [ -1+A>=2 && 2*meter==-2+A ] WORST_CASE(Omega(n^1),?) ---------------------------------------- (2) BOUNDS(n^1, INF)