Lower Bounds for Anytime Acceleration of Gradient Descent
Abstract: Recent work suggests that the convergence rate of gradient descent (GD) in smooth convex optimization can be significantly improved by employing large stepsizes that may violate the descent property. In particular, if the total number of iterations $n$ is given, an $O(n{-1.271})$ convergence rate can be achieved for both function value and squared gradient norm minimization. On the other hand, in the setting of anytime convergence, where $n$ is not known in advance, the best known rates of GD are much slower: $O(n{-1.119})$ for function value minimization and $O(n{-1})$ for squared gradient norm minimization. It remains open whether any of these upper bounds can be improved, as they are far from the classical $Ω(n{-2})$ lower bound for any first-order method. In this work, we establish two lower bounds on the anytime convergence of GD. We show that no positive stepsize schedule can achieve an $o(n{-1.334})$ anytime rate for function value minimization, nor an $o(n{-1})$ anytime rate for squared gradient norm minimization. The key ingredients of our analysis are novel upper bounds on the number and the magnitude of large stepsizes, derived by analyzing GD on quadratic functions and variants of Huber functions. Our work provides the first lower bounds for the COLT 2024 open problem posed by Kornowski and Shamir regarding the optimal anytime convergence rates of GD.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What this paper is about
This paper asks a simple-sounding question about a very common algorithm called gradient descent, which is like walking downhill to the bottom of a valley: How fast can it reliably get you close to the bottom if you don’t know in advance how many steps you’ll take?
The authors show that, even if you allow some very large steps that sometimes go “too far” and briefly go uphill, there are hard limits on how quickly plain gradient descent can improve when your step plan must work at any time you decide to stop.
The main goal and questions
The paper studies two ways to measure “how close to the bottom” you are after n steps:
- Function value gap Rₙ: how much higher your height is compared to the lowest possible.
- Gradient norm Gₙ: how steep the ground is where you stand (zero means flat, i.e., at the bottom).
The key questions are:
- If you don’t know in advance how many steps you’ll take (an “anytime” setting), can you design step sizes that make gradient descent shrink the error much faster than the usual 1/n rate for:
- the function value (Rₙ)?
- the gradient norm (Gₙ)?
Past work showed that if you do know n ahead of time, you can sometimes beat 1/n by carefully planning some large steps. But in the “anytime” setting, the best known rates were slower, and it was open whether they could be improved.
How they studied it (in simple terms)
Think of walking downhill with a pre-planned list of step sizes: big or small strides, all chosen before you start, and always positive (no stepping backward).
The authors use two main ideas, designed to be easy to analyze:
- Simple bowl-shaped functions (quadratics):
- These are like perfectly smooth, round bowls. On such bowls, gradient descent’s progress is easy to write down exactly.
- Mathematically, each step multiplies your distance by a factor depending on the step size. Multiplying many such factors is like evaluating a polynomial.
- If too many step sizes are “large,” these factors can make the product blow up. So they prove a limit on how many large steps you can take if you want steady improvement.
- “Asymmetric Huber” functions (a bowl with flat sides and a steep middle):
- Imagine a shape that’s flat on the sides and steep only in the center slice.
- They set things up so that one chosen step lands you in the steep middle. If that step is too large, you overshoot to the other side. After that, because the sides are flat, even many more steps don’t help much. That means your final error can’t be too small if any single step was huge.
- This gives a cap on how big any single step can be if your overall progress must be fast.
By combining “you can’t have too many large steps” with “no single step can be too large,” they show strong limits on how fast gradient descent can improve in the anytime setting.
What they found and why it matters
Here are the main takeaways:
- Function value gap (Rₙ): You cannot achieve a rate faster than about 1/n1.334 in the anytime setting with positive, pre-chosen step sizes. In other words, you can’t get all the way to the much faster 1/n2 that some other, more advanced methods can reach.
- Gradient norm (Gₙ): You cannot beat 1/n in the anytime setting with positive, pre-chosen step sizes. This matches the best known upper bound, so 1/n is optimal here.
- Separation between knowing n and not knowing n:
- If you know ahead of time how many steps you’ll take, you can do better (about 1/n1.271) than 1/n for both measures by using carefully planned large steps.
- If you don’t know when you’ll stop (anytime), for the gradient norm you cannot do better than 1/n. That quantifies “the price” of not knowing the stopping time.
Why this matters:
- For the function value, the best possible anytime rate is now pinned between about 1/n1.334 (this paper’s lower bound) and about 1/n1.119 (best known upper bound). The exact answer is still open.
- For the gradient norm, the story is settled: 1/n is the best you can hope for with plain gradient descent and positive, pre-chosen step sizes.
- It shows that simply taking occasional giant steps isn’t a magic recipe when you need an anytime guarantee; you’re limited in both how many and how big those steps can be if you want reliable progress at every possible stopping time.
Big-picture implications
- Plain gradient descent with positive, pre-set step sizes is provably not as fast as more advanced methods that can reach 1/n2 for the function value.
- If your goal is to make the gradient small (so the ground is flat), and you need a plan that works whenever you stop, 1/n is the best you can do with this kind of gradient descent.
- The paper provides the first lower bounds answering a COLT 2024 open problem on “anytime” rates for gradient descent.
- Their techniques also give helpful design hints: any plan that aims for very fast anytime convergence must carefully limit both how often and how much it uses large steps.
In short, the paper sets clear speed limits for how fast basic gradient descent can go in the anytime setting and helps explain why clever step-size tricks that work when you know the finish line don’t translate to the “stop anytime” world.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a concise, actionable list of gaps and open problems left unresolved by the paper. Each item focuses on what is missing, uncertain, or left unexplored, and suggests concrete directions for future work.
- Determine the exact optimal anytime rate for function value : close the current gap between the best upper bound and the new lower bound ruling out . Either:
- construct an anytime stepsize schedule achieving with , or
- strengthen the lower bound (beyond $4/3$ or with reduced constants/logs) to match/improve upon $1.119$.
- Strengthen the nature of the lower bound for from a uniform “no for all ” statement to finer notions:
- rule out even (not just ), or
- characterize subsequence behavior by bounding / of , or
- show that achieving for infinitely many is impossible.
- Establish stronger (GD-specific) non-anytime lower bounds: move beyond the general first-order lower bound to any lower bound that reflects GD’s known non-anytime upper bound . Ideally, characterize the optimal non-anytime rate of GD.
- Design or rule out an explicit anytime schedule achieving for (the paper’s lower bound does not preclude this exact order), and clarify whether matching constant factors/logarithms can be achieved.
- Extend lower bounds beyond positive, non-adaptive stepsizes:
- negative or sign-changing stepsizes,
- adaptive step rules that depend on past iterates/gradients (e.g., line-search, AdaGrad-type rules),
- randomized anytime schedules independent of the function instance.
- Determine whether such extensions can circumvent the anytime lower bound or improve .
- Analyze the alternative gradient-norm metric where the normalization is $2\|x_1-x^\*\|^2$ (instead of $f(x_1)-f(x^\*)$). The paper notes the metric change dramatically alters known rates but does not study anytime lower bounds in this setting.
- Extend the results from last-iterate performance to other iterate selections:
- suffix-averaged or fully averaged iterates,
- best iterate (min over ),
- and determine whether analogous anytime lower bounds hold for and .
- Investigate whether momentum-based methods restricted to GD-like update structures (e.g., heavy-ball with fixed coefficients, Nesterov’s method under similar positivity constraints) admit analogous anytime lower bounds, or can surpass the GD barriers identified here.
- Improve or fully characterize the tradeoff between number and magnitude of large steps:
- tighten Lemma 2.2 by removing or reducing the additive term and sharpening constants,
- provide matching lower bounds for under prescribed scaling,
- characterize necessary and sufficient conditions on the stepsize measure for achieving a target rate.
- Sharpen the magnitude bounds in Lemma 3.1:
- derive permutation-invariant bounds (current bound depends on the position of a large step),
- obtain stronger dependence on partial sums and ,
- explore alternative adversarial constructions beyond asymmetric Huber functions to tighten the exponent.
- Develop refined polynomial-approximation arguments for :
- identify or approximate the maximizing in ,
- convert these refinements into sharper bounds on and .
- Examine whether randomization in stepsize sequences (chosen independently of the instance but fixed in advance) affects worst-case anytime rates for or .
- Generalize to other convex settings:
- strongly convex objectives (dependence on condition number, and whether anytime lower bounds tighten),
- composite/proximal settings (proximal GD), where worst-case analyses can differ from smooth-only GD.
- Provide constructive “near-optimal” schedule designs guided by the necessary conditions in Section 5.1 (e.g., along indices with and ) and empirically test whether they approach the conjectured frontier for .
- Characterize whether separations between anytime and non-anytime rates extend to other performance measures (e.g., average gradient norm over iterations, stationarity measures), beyond the specific and definitions used.
- Assess robustness of the lower bounds to model variations:
- unknown or misspecified smoothness constant (scaling/normalization effects),
- stochastic or noisy gradients (do analogous anytime lower bounds persist in expectation/high probability?).
- Close constant and logarithmic-factor gaps throughout (e.g., in Lemmas 2.2, 2.3, 3.1), aiming for matching upper/lower bounds not only in exponent but also in prefactors, to enable precise rate optimality claims.
Practical Applications
Immediate Applications
Below are actionable uses that can be deployed now, leveraging the paper’s lower bounds, proof techniques, and explicit constructions.
- Training policy for unknown-horizon optimization (software/ML; industry, academia)
- Action: When the stopping time n is not known in advance and the objective is small gradients (squared gradient norm), prefer simple constant stepsizes or established adaptive methods; do not expect anytime acceleration beyond O(1/n) with positive, non-adaptive gradient descent (GD).
- Why: Theorem 1.2 proves no o(n{-1}) anytime rate for the squared gradient norm with positive, preplanned stepsizes.
- Tools/workflow: Update default optimizers (PyTorch, TensorFlow, JAX, scikit-learn) to recommend or auto-select constant learning rates for “stationarity-driven” tasks (e.g., stopping at small gradient norm).
- Dependencies/assumptions: Smooth convex objectives; last iterate; positive, non-adaptive stepsizes.
- Practical “anytime” schedule selection for loss minimization (software/ML; industry)
- Action: If the goal is reducing function value (loss) with unknown horizon, use the known anytime-accelerated schedule achieving O(n{-1.119}) for Rn (Zhang et al. 2025). Avoid aiming for o(n{-4/3}) which the paper rules out.
- Why: Theorem 1.1 bounds the best-possible anytime rate between n{-1.334} and n{-1.119}.
- Tools/workflow: Package an “Anytime Loss Scheduler” that defaults to the O(n{-1.119}) schedule and provides guardrails on step magnitudes (see below).
- Dependencies/assumptions: Smooth convex; last iterate; positive, non-adaptive stepsizes.
- Guardrails for large stepsizes in production training (software/ML; industry)
- Action: Enforce frequency and magnitude caps on large steps during training runs with unknown horizon.
- Why: Lemma 2.2 bounds the number of large steps; Lemma 3.1 links an oversized step to provably slower convergence. Together they inform safe thresholds.
- Tools/products:
- “LR Auditor” that, given a preplanned schedule, computes Nn(t) and max step Mn and flags schedules exceeding safe envelopes: Nn(t) ≲ log n + √t (up to constants) and nm ≲ 1 + (1 + sum of prior steps)√rate.
- Runtime monitors that track running sum of stepsizes and the count of steps > t; auto-throttle overly large steps that would push the lower-bound risk up.
- Dependencies/assumptions: Preplanned (non-adaptive) steps; smooth convex.
- Horizon-aware block scheduling to harvest non-anytime gains when possible (software/ML; industry)
- Action: When you can partition training into blocks with known iteration budgets (e.g., per epoch/phase), use non-anytime “long-step” schedules (e.g., silver schedule) within each block; reset between blocks.
- Why: Non-anytime GD can achieve O(n{-1.271}) for both Rn and Gn when the horizon is known; the paper quantifies the cost of not knowing n.
- Tools/workflow: “Budgeted Acceleration” module that:
- Detects known near-term budgets (e.g., 1k-step phases) and switches to silver/concatenated schedules within those windows.
- Falls back to anytime-safe scheduling when the budget is unknown.
- Dependencies/assumptions: Budget known per block; smooth convex; last-iterate focus.
- Resource and SLA planning for convex learning/analytics (finance, healthcare analytics, operations; industry)
- Action: Plan compute and time-to-accuracy using the tight O(1/n) anytime limit for gradient norms and the n{-1.119}–n{-1.334} window for loss; avoid overpromising faster anytime convergence with plain GD.
- Why: The paper closes the Gn anytime gap and tightens expectations for Rn.
- Tools/workflow: Estimators that translate tolerance targets (e.g., ||∇f||2 ≤ ε) into iteration/time budgets using 1/ε scaling for GD with unknown horizon.
- Dependencies/assumptions: Tasks reasonably modeled as smooth convex.
- Benchmarking and claims auditing (policy/standards; academia, industry)
- Action: Review and standardize claims about “anytime acceleration” from large learning rates in GD; require disclosure of horizon knowledge and step sign/adaptivity.
- Why: The results place hard limits on what positive non-adaptive GD can achieve; avoids misleading comparisons.
- Tools/workflow: Conference/journal reviewer checklists; “optimizer certification” badges indicating whether results are anytime/non-anytime and within known bounds.
- Dependencies/assumptions: Applies specifically to positive, preplanned GD; other methods may fall outside the scope.
- Teaching modules and diagnostic datasets (education; academia)
- Action: Incorporate the paper’s constructions (quadratic and asymmetric Huber) into coursework and optimizer labs to illustrate worst-case behavior and the price of unknown horizons.
- Why: The proofs provide tangible hard instances and intuitive phenomena (overshooting vs. linear regions).
- Tools/workflow: Notebooks generating these instances; exercises that count large steps Nn(t) and visualize their effect on convergence.
- Dependencies/assumptions: Educational use; convex smooth setting.
- Federated/edge learning with uncertain participation (software/ML; industry)
- Action: For clients with unpredictable horizons, use constant or conservative schedules; reserve long-step schedules for server-side stages with known aggregation rounds.
- Why: Anytime limits apply on devices with uncertain stop times; non-anytime acceleration can be used where round budgets are set.
- Tools/workflow: Client-side “anytime-safe” SGD; server-side budgeted accelerated phases.
- Dependencies/assumptions: Smooth convex surrogates or proximal subproblems.
- Early-stopping and monitoring policies (daily practice; industry)
- Action: Track the running sum of stepsizes and the largest recent step; if large overshoots occur without known horizon, reduce stepsize to avoid guaranteed slowdowns implied by Lemma 3.1.
- Why: Big mid-run steps can provably hurt the last-iterate rate when the horizon is unknown.
- Tools/workflow: Dashboard indicators: sum of steps so far, max step so far, and theoretical risk meters derived from the paper’s inequalities.
- Dependencies/assumptions: Smooth convex; last iterate.
Long-Term Applications
These opportunities require additional research, engineering, or scaling beyond the paper’s immediate scope.
- New optimizer classes to bypass the lower bounds (software/ML; industry, academia)
- Goal: Design methods outside the paper’s constraint set (e.g., negative stepsizes, momentum/acceleration, iterate averaging, adaptive rules like AdaGrad/Adam) that can achieve anytime improvements for gradient norms or match accelerated loss rates.
- Why: The lower bounds target positive, non-adaptive, last-iterate GD; alternative update rules may evade this barrier.
- Dependencies/assumptions: Careful stability analysis; may change convergence guarantees and practical tuning.
- Horizon-estimating schedulers and adaptive “anytime-to-budgeted” switching (software/ML; industry)
- Goal: Online estimation of remaining budget/time to convert an unknown-horizon run into a sequence of short “known-horizon” blocks, enabling non-anytime accelerated schedules inside each block.
- Why: The paper quantifies the price of ignorance; improving horizon estimates can reclaim acceleration.
- Tools/products: Learning-rate controllers that infer or negotiate budgets with job schedulers; integration with cluster workload managers.
- Dependencies/assumptions: Accurate budget prediction; safe transitions.
- Worst-case instance generators and certification suites (software/ML tools; academia, industry)
- Goal: Turn the quadratic and asymmetric Huber constructions into standardized hardness suites for testing optimizers’ anytime vs. non-anytime behavior.
- Why: Encourages robust optimizer design and honest reporting under worst-case scenarios.
- Tools/products: Open-source “Convex-Anytime-Bench” with configurable dimension, smoothness, and step-schedule validators.
- Dependencies/assumptions: Benchmark relevance to target applications.
- Performance Estimation Programming (PEP) enhancements and solver design (academia)
- Goal: Use the paper’s bounds on the number/magnitude of large steps to sharpen PEP-based analyses and to co-design optimal schedules under operational constraints (e.g., bounded overshoot frequency).
- Why: Bridges theory (polynomial norms, layer-cake arguments) and automated optimizer design.
- Dependencies/assumptions: Advances in PEP tooling and tractable formulations.
- Energy- and cost-aware training planners (energy, finance; industry)
- Goal: Embed the anytime limits into planners that trade off accuracy vs. energy/cost, avoiding futile attempts to beat O(1/n) for gradient norm with GD when horizons are unknown.
- Why: Prevents wasteful runs chasing unattainable rates; aligns compute budgeting with theoretical limits.
- Dependencies/assumptions: Reliable mapping from iterations to energy/cost in target infrastructure.
- Formal standards for optimizer reporting (policy/standards; academia, industry)
- Goal: Develop reporting templates that declare whether results are anytime or non-anytime, step sign/adaptivity, last-iterate vs. averaged metrics, and whether bounds like those in this paper apply.
- Why: Improves reproducibility and comparability across papers and products.
- Dependencies/assumptions: Community buy-in; standards bodies or conference policies.
- Domain-specific convex pipelines with horizon-aware phases (healthcare, finance, operations; industry)
- Goal: Architect analytic pipelines that segment convex optimization tasks into known-budget phases (e.g., screening, refinement), enabling non-anytime acceleration where safe.
- Why: Leverages organizational control of phases to sidestep anytime limits in critical sub-steps.
- Dependencies/assumptions: Ability to restructure workflows; validation for domain constraints.
- Extending lower/upper bounds beyond current scope (academia)
- Goal: Prove non-anytime lower bounds tighter than Ω(n{-2}) for GD or find schedules that meet the current upper bounds for anytime Rn; analyze averaged iterates and adaptive/negative-step variants.
- Why: The paper highlights open gaps (e.g., optimal anytime rate for Rn; non-anytime lower bounds).
- Dependencies/assumptions: New analytical techniques (beyond the current quadratic/Huber constructions).
- AutoML integration with theory-aware optimizer selection (software/ML; industry)
- Goal: AutoML systems that choose between anytime-safe GD, budgeted-accelerated GD, or alternative methods (e.g., adaptive/momentum) based on objective (loss vs. gradient), horizon visibility, and risk tolerance.
- Why: Encodes the paper’s decision logic into automated pipelines.
- Dependencies/assumptions: Accurate meta-learning of horizon/objective priorities; robust fallback strategies.
Notes on assumptions and scope
- These applications rely on the paper’s setting: smooth convex optimization, last-iterate performance, positive non-adaptive stepsizes. Many modern deep learning tasks are nonconvex and use adaptive or momentum methods; the bounds do not directly apply but provide conservative guidance when using plain GD or when convex subproblems arise.
- The constructions are univariate yet inform worst-case behavior more broadly; practical impact is strongest in convex ML (e.g., logistic regression), signal processing, and operations research where smooth convex models are standard.
- Where anytime acceleration of gradient norm is required, one should consider methods outside the paper’s class (e.g., averaging, adaptivity, momentum, or even negative stepsizes), each introducing its own assumptions and trade-offs.
Glossary
- Accelerated rate: A convergence rate faster than the standard O(n{-1}) rate, typically o(n{-1}). "We call any rate of order an accelerated rate."
- Anytime convergence: A guarantee that holds for all iteration counts without knowing the stopping time in advance. "In this work, we establish two lower bounds on the anytime convergence of GD."
- Asymmetric Huber functions: Piecewise convex functions with a quadratic region around zero and linear tails with different slopes on the positive and negative sides. "We introduce the asymmetric Huber functions, which are parameterized by and and are defined as"
- Counting measure: A measure that counts occurrences, here summing Dirac masses at observed stepsizes. "be the counting measure of the first stepsizes"
- Convex quadratic function: A convex function of the form (λ/2)x2 used as a canonical test case in optimization analysis. "In this section, we present an in-depth analysis of the convergence rate of GD on convex quadratic functions."
- Descent property: The property that each iteration decreases the objective value. "employing large stepsizes that may violate the descent property."
- Dirac measure: A measure concentrated at a single point carrying unit mass. "where denotes the Dirac measure at ."
- First-order method: An optimization algorithm that accesses the objective via gradients (and possibly function values) only. "the classical lower bound for any first-order method."
- Huber function: A piecewise function that is quadratic near zero and linear in the tails, blending L2 and L1 behavior. "both of which can be derived from the Huber function:"
- Huber-like function: A variant of the Huber function constructed to create challenging optimization instances. "while they constructed a Huber-like function that is difficult for GD to optimize with a large last stepsize, we generalize their construction"
- Infinity norm (of a polynomial): The maximum absolute value of a polynomial over a specified interval. "The infinity norm of a polynomial over an interval $[a,b]\subseteqR$ is defined as ."
- L-smooth (function): A function whose gradient is L-Lipschitz continuous. "Let denote the class of -smooth convex functions on "
- Layer-cake representation: An integral identity expressing integrals of nonnegative functions via integrals over level sets. "by invoking the layer-cake representation (\Cref{lem:layer_cake})"
- Non-adaptive (stepsize schedule): A stepsize policy fixed in advance that does not depend on past iterates or gradients. "non-adaptive,\footnotemark{} yet not necessarily bounded stepsize schedule."
- Non-anytime convergence rate: A rate that can depend on a known horizon n and may use this knowledge in its stepsizes. "An accelerated non-anytime convergence rate for was proved concurrently by Altschuler and Parrilo~\cite{altschuler:2024b} and Grimmer et al.~\cite{grimmer:2023}, with the best known rate of order "
- Oracle complexity: The number of information queries (e.g., gradient evaluations) required to reach a target accuracy. "any first-order method must have an oracle complexity"
- Permutation-invariant: A property that is unchanged under reordering of elements (here, stepsizes). "they are not permutation-invariant"
- Polylogarithmic factor: A multiplicative factor that is a polynomial in logarithms of the problem size or horizon. "they differ by a polylogarithmic factor in non-smooth convex optimization"
- Silver ratio: The constant ρ = 1 + √2 ≈ 2.414, appearing in exponents of optimal rates. "where is the silver ratio."
- Silver stepsize schedule: A specific sequence of stepsizes based on the silver ratio that yields accelerated (non-anytime) rates. "in the silver stepsize schedule of Altschuler and Parrilo~\cite{altschuler:2024b}"
- Squared gradient norm: The quantity ||∇f(x)||2 used as a stationarity measure and optimization objective. "squared gradient norm minimization."
- Stepsize schedule: The sequence of step lengths used by gradient descent across iterations. "Given a stepsize schedule $=(\eta_k)_{k\inN}$"
- Weierstrass product inequality: An inequality bounding products by one minus sums under suitable conditions, used to control product terms. "where the last inequality follows from the Weierstrass product inequality."
- Worst-case convergence rate: The largest (slowest) error over all problem instances, normalized appropriately, after n iterations. "There are multiple ways of defining the worst-case convergence rate of an iterative algorithm"
Collections
Sign up for free to add this paper to one or more collections.