Convex optimization textbooks, chapter by chapter: KKT conditions, conic duality, barrier methods, and the complexity of first-order methods from center of gravity to mirror descent.
Log-concave functions are the meeting point of convex analysis and probability: densities of Gaussian, exponential, uniform and Wishart distributions are all log-concave, and countless facts of applied probability flow from one structural theorem — integrating out variables preserves log-concavity. This mission builds the convex-analysis spine of Boyd & Vandenberghe's Convex Optimization (Chapters 2–3) — separation and supporting hyperplanes, dual cones, the first- and second-order differential characterizations of convexity, Fenchel conjugacy — and climbs to Prékopa's theorem via the Prékopa–Leindler inequality, a landmark of Brunn–Minkowski theory absent from Mathlib.
The Karush–Kuhn–Tucker conditions are the central result of convex optimization: for a convex differentiable problem satisfying Slater's condition, a point is optimal exactly when primal feasibility, dual feasibility, complementary slackness and Lagrangian stationarity hold. This mission formalizes Chapters 4–5 of Boyd & Vandenberghe end to end — the first-order optimality criterion, concavity of the Lagrange dual, weak duality, Slater's strong-duality theorem with dual attainment (via the separating-hyperplane argument of §5.3.2), the saddle-point characterization, sensitivity bounds and Pareto scalarization — culminating in the full KKT characterization.
Every full-dimensional convex body is sandwiched between an ellipsoid and its n-fold dilation: shrinking the minimum-volume covering (Löwner–John) ellipsoid E about its centre x0 by the factor 1/n lands inside the body,
x0+n1(E−x0)⊆C⊆E,
and the factor n is tight on simplices. This rounding theorem underlies the ellipsoid method, John's theorem on the Banach–Mazur distance to the Euclidean ball, and much of modern convex geometry. The mission formalizes §8.4 of Boyd & Vandenberghe for polytopes C=conv{x1,…,xm}, exactly as the book proves it: existence and uniqueness of the extremal ellipsoid, the KKT identities at the normalized optimum (∑iλixixiT=I, ∑iλixi=0, ∑iλi=n), the convex-combination step that produces the 1/n ball, and affine invariance.
The classical convergence theory of smooth convex minimization. For a function that is m-strongly convex and M-smooth (mI⪯∇2f(x)⪯MI), gradient descent converges linearly, while Newton's method exhibits its famous two phases: a damped phase in which every backtracking step decreases the objective by a fixed amount γ, and a quadratically convergent phase in which the scaled gradient norm squares at each step, 2m2L∥∇f(x+)∥2≤(2m2L∥∇f(x)∥2)2. Together they give the iteration count of B&V (9.36),
with L the Lipschitz constant of the Hessian and α,β the backtracking parameters. This mission formalizes Chapters 9–10 of Boyd & Vandenberghe with every constant exactly as printed — a quantitative theory entirely absent from Mathlib.
Convex Optimization III: Conic Duality and the S-procedureTextbook
Two quadratic functions can be compared losslessly. The S-procedure says that, when the constraint is strictly feasible, the implication
q1(x)≤0⟹q2(x)≤0,qk(x)=xTFkx+2gkTx+hk,
holds if and only if a single nonnegative multiplier certifies it as a matrix inequality, λ[F1g1Tg1h1]⪰[F2g2Tg2h2] for some λ≥0. It is a cornerstone of control theory, trust-region methods and robust optimization, and a rare case in which a nonconvex problem has zero duality gap. The route runs through the theory this mission builds from Boyd & Vandenberghe §5.8–5.9 and Appendix B: strong alternatives for convex inequality systems, cone-program strong duality under a generalized Slater condition, semidefinite programming duality, the LMI theorems of alternatives, and the hidden convexity of the joint range of two quadratic forms.
Convex Optimization VI: Self-Concordance and the Barrier MethodTextbook
Why do interior-point methods solve convex programs in O(mlog(1/ε)) Newton steps? Nesterov and Nemirovskii's answer is self-concordance: a convex function whose third derivative is controlled by its second, ∣φ′′′(t)∣≤2φ′′(t)3/2 along every line, admits a Newton analysis with absolute constants and no condition number — and the logarithmic barrier is self-concordant. This mission formalizes §9.6 and Chapter 11 of Boyd & Vandenberghe: the self-concordance calculus, the Newton-decrement analysis, the duality gap m/t along the central path, the per-centering work bound m(μ−1−logμ)/γ+c, and the crown result — with the aggressive schedule μ=1+1/m the barrier method reaches duality gap ε after
⌈mlog2(m/(t(0)ε))⌉
centering steps, each of uniformly bounded Newton cost.
Convex Optimization: Algorithms and Complexity I: The Center of Gravity Method Satisfies f(x_t) − min f ≤ 2B(1 − 1/e)^{t/n}Textbook
Motivation
Black-box convex optimization asks how many queries to an oracle are needed to minimize a convex function to accuracy ε. In fixed dimension n the answer is of order nlog(1/ε), and the first algorithm to attain it is the center of gravity method, discovered independently by Levin (1965) and Newman (1965). It is the opening example of cutting plane methods: algorithms that keep a set known to contain a minimizer and shrink it with one half-space per oracle call. The ellipsoid method and Vaidya's method, which underlie the polynomial-time solvability of linear programming and convex feasibility problems, follow the same template with cheaper sets. This mission is the first of a series formalizing S. Bubeck's monograph Convex Optimization: Algorithms and Complexity (2015), and covers its §2.1.
Timeline:
1960: B. Grünbaum proves that every half-space whose boundary passes through the centroid of a convex body in Rn contains at least a fraction (n/(n+1))n≥1/e of its volume.
1965: A. Levin and D. J. Newman independently introduce the center of gravity method and prove its linear rate.
1983: A. Nemirovski and D. Yudin show that Ω(nlog(1/ε)) oracle calls are necessary for small ε, so the method's oracle complexity is optimal.
Setting
Let X⊂Rn be a convex body: a compact convex set with non-empty interior. Let f:X→[−B,B] be continuous and convex, and let x∗∈X be a minimizer of f on X. A vector w is a subgradient of f at x∈X if f(x)−f(y)≤w⊤(x−y) for every y∈X. The first order oracle returns, at a query point, some subgradient there; the zeroth order oracle returns the value of f.
For a set S of finite positive volume, its center of gravity is
c(S)=vol(S)1∫x∈Sxdx.
The center of gravity method sets S1=X and, for t≥1, computes ct=c(St), queries the first order oracle at ct to obtain a subgradient wt, and sets
St+1=St∩{x∈Rn:(x−ct)⊤wt≤0}.
After t steps it outputs xt∈argmin1≤r≤tf(cr), found with t calls to the zeroth order oracle.
The Lean development names these objects IsConvexBody, IsSubgradientOn, centroid and IsCenterOfGravityRun in the namespace ConvexOptAlg.CenterGravity.
Formalization targets
Goal: Theorem 2.1 (p. 245)
For every run of the method and every t≥1,
f(xt)−x∈Xminf(x)≤2B(1−e1)t/n.
Milestones (proof of Theorem 2.1, pp. 246–247)
Lemma 2.2 (Grünbaum). If K is centered, ∫Kxdx=0, then for every w=0,
Vol(K∩{x:x⊤w≥0})≥e1Vol(K).
(2.2).St∖St+1⊂{x∈X:(x−ct)⊤wt>0}⊂{x∈X:f(x)>f(ct)}, hence x∗∈St for every t.
Volume decay. If ws=0 for s≤t, then vol(St+1)≤(1−1/e)tvol(X).
Shrunk copies. For ε∈[0,1] and Xε={(1−ε)x∗+εx:x∈X}, vol(Xε)=εnvol(X).
Values on shrunk copies. Every xε∈Xε satisfies f(xε)≤f(x∗)+2εB.
Significance
Theorem 2.1 is a linear rate whose number of queries to reach accuracy ε, O(nlog(2B/ε)), depends on the dimension only linearly and on the accuracy only logarithmically, and matches the Nemirovski–Yudin lower bound. It is the reference point against which the ellipsoid method (O(n2log(1/ε)) queries) and Vaidya's method are measured, and the randomized center of gravity method of §6.7 of the book rests on the same analysis. Grünbaum's inequality is a basic fact of convex geometry with uses well beyond optimization, for instance in the analysis of query complexity and of approximate centroid computations by random walks.
On the formal side, the theorem has been proved since 1965 and the lemma since 1960; neither is known to have a machine-checked proof. A complete development adds to Mathlib-based libraries the center of gravity of a set, the volume of homothetic images in the form used here, Grünbaum's inequality, and a reusable predicate for cutting plane runs. The later missions of this series (the ellipsoid method in particular) reuse the shrunk-copy argument of milestones 4 and 5.
Difficulty
The steps (2.2), the shrunk-copy volume and the value bound are short. The volume decay and the final comparison are bookkeeping once one knows that each cut keeps the method's sets convex bodies with positive volume. The difficulty is Lemma 2.2. A half-space through the centroid need not split the volume evenly: for a cone the smaller side tends to 1/e of the volume as n→∞, so no symmetry argument works, and the bound must hold uniformly in the dimension. The classical proofs rely on tools of convex geometry, such as volume comparisons between a body and a symmetrized body, that are not available in Lean in the needed form. A second source of work is that the method's sets are defined through centroids: it has to be shown that they remain convex bodies of positive volume, so that each centroid is the genuine center of gravity, and this fact is not available before the volume estimates are.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n) with Lebesgue measure volume; volumes are kept in [0,∞] in every statement. The function is a total map f : EuclideanSpace ℝ (Fin n) → ℝ with ∣f∣≤B, continuity and convexity required on X only; its values off X are irrelevant. Subgradients are relative to X (Definition 1.2). A run is a predicate on sequences indexed from 1; the oracle's choice of subgradient is free, and every theorem holds for all runs. The minimizer x∗ is a hypothesis, as in the book's standing notation; it exists here by compactness. The output xt is any argmin, so the goal bounds the minimum min1≤r≤tf(cr).
Added hypotheses, all disclosed in the statements: n≥1 in the goal, because the exponent t/n is undefined for n=0; and in Lemma 2.2, that the centered set is a convex body, because in Lean the integral of a non-integrable function is 0, which would make every unbounded convex set "centered". The milestone on volume decay assumes ws=0, which is the book's own reduction.
The center of gravity is defined with the real volume vol(S) and is meaningless when that volume is 0 or infinite. The run predicate does not assume the volumes are positive; that every set of a run is a convex body of positive volume is part of what has to be proved, and a formalization in which runs could degenerate to sets of zero volume, or in which the centroid is an arbitrary point, is not the book's method.
Contributions welcome: proofs of any item; a general Grünbaum inequality for convex sets of finite positive volume; lemmas on centroids (membership in the closed convex hull, translation behaviour) that later missions can reuse.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980v2, §2.1. https://arxiv.org/abs/1405.4980
B. Grünbaum, Partitions of mass-distributions and of convex bodies by hyperplanes, Pacific Journal of Mathematics 10(4):1257–1261, 1960. https://doi.org/10.2140/pjm.1960.10.1257
A. Yu. Levin, On an algorithm for the minimization of convex functions, Soviet Mathematics Doklady 6:286–290, 1965.
Convex Optimization: Algorithms and Complexity II: For t ≥ 2n² log(R/r) the Ellipsoid Method Satisfies f(x_t) − min f ≤ (2BR/r)·exp(−t/(2n²))Textbook
Motivation
The ellipsoid method is the cutting-plane algorithm that settled the polynomial-time solvability of linear programming and, more generally, of convex optimization over any set that comes with an efficient separation oracle. It was introduced for convex minimization by Shor and by Yudin and Nemirovski in the 1970s, and Khachiyan used it in 1979 to give the first polynomial-time algorithm for linear programming. Grötschel, Lovász and Schrijver later turned it into the general equivalence between separation and optimization that underlies much of combinatorial optimization.
This mission is the second of a series formalizing S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning 8(3–4), 2015; arXiv:1405.4980v2). Its goal is the convergence guarantee of the ellipsoid method, Theorem 2.4 (p. 250), together with the geometric lemma and the steps of the proof on which it rests.
Timeline:
1976–1977: Yudin–Nemirovski and Shor introduce the method for convex minimization.
1979: Khachiyan applies it to linear programming and obtains polynomial time.
1981: Grötschel, Lovász and Schrijver derive the equivalence of separation and optimization.
Setting
Write Rn for the space of real n-vectors, with the dot product x⊤y. An ellipsoid is a set
E={x∈Rn:(x−c)⊤H−1(x−c)≤1},
where c∈Rn is its center and H is a symmetric positive definite matrix.
A convex bodyX⊂Rn is a compact convex set with non-empty interior. The objective f is continuous and convex on X with values in [−B,B], and r,R>0 are such that X lies in the Euclidean ball E0 of center c0 and radius R and contains some Euclidean ball of radius r. A subgradient of f at x∈X is a vector g with f(x)+g⊤(y−x)≤f(y) for all y∈X.
The method starts from E0, H0=R2In. At step t≥0 it asks for a vector wt:
if ct∈/X, a separating vector, with X⊂{x:(x−ct)⊤wt≤0};
otherwise a subgradient of f at ct.
It then replaces Et by the ellipsoid Et+1 given by
After t iterations the output xt is the best of the queried centers that lie in X.
Formalization targets
Goal: Theorem 2.4
For n≥2 and every t≥2n2log(R/r), t≥1, some queried center lies in X, and every output satisfies
f(xt)−x∈Xminf(x)≤r2BRexp(−2n2t).
Milestones
The scalar inequality (1+1/n)2(1−1/n2)n−1≥exp(1/n) for n≥2 (proof of Lemma 2.3, pp. 248–249).
Lemma 2.3 (p. 247): for w=0 the half-ellipsoid {x∈E0:w⊤(x−c0)≤0} lies in an ellipsoid E with
vol(E)≤exp(−2n1)vol(E0),
and for n≥2 the explicit ellipsoid (2.5)–(2.6) works.
3. The remark before Theorem 2.4 (p. 250): a point of X can leave the current ellipsoid only at a step with ct∈X, and then its value exceeds f(ct).
4. Two steps reused from Theorem 2.1 (pp. 246–247): vol(Xε)=εnvol(X) for Xε=(1−ε)x∗+εX, and f≤f(x∗)+2εB on Xε.
Significance
Theorem 2.4 bounds the oracle complexity of the ellipsoid method: accuracy ε needs O(n2log(1/ε)) oracle calls. Each step costs O(n2) arithmetic operations plus one oracle call. With the separation oracles of linear and semidefinite programs this gives polynomial overall complexity (p. 250). The rate depends on the instance only through log(R/r) and B, so the method needs no smoothness and no strong convexity. Lemma 2.3 is also the geometric step of the ellipsoid method for linear feasibility.
The result has a textbook proof. The work of this mission is to formalize it. The same update is published on the platform from Bertsimas and Tsitsiklis's Introduction to Linear Optimization (Theorem 8.1), with a proved volume factor of exp(−1/(2(n+1))). That factor is weaker than (2.4)'s exp(−1/(2n)) and does not give Theorem 2.4's constant. The sharper factor and the optimization version of the method (subgradient cuts, the output rule and the value bound) are not formalized on the platform.
Difficulty
There are two difficulties: Lemma 2.3 with the sharp constant, and the bookkeeping that turns per-step volume decrease into a value bound.
For the lemma, the volume of the explicit ellipsoid is (n/n2−1)n(n−1)/(n+1) times that of E0. Bounding it by exp(−1/(2n)) rather than by the cruder exp(−1/(2(n+1))) needs the scalar inequality of milestone 1 for every n≥2. The reduction from a general ellipsoid to the unit ball also needs determinants under an affine map.
For the theorem, the obvious argument compares vol(Xε) with vol(Et). This only works if no cut removes an optimal point and if every removed point of X is worse than a queried center. At the threshold t=2n2log(R/r) the admissible ε is exactly 1, so a non-strict volume bound alone does not close the argument there.
Formalization scope
Rn is Fin n → ℝ with Lebesgue measure, as in the reused Bertsimas–Tsitsiklis ellipsoid definitions (LinearOptimization.ellipsoid, ellipsoidUpdateCenter, ellipsoidUpdateMatrix, IsSubgradientOn).
Euclidean balls are written with the dot product, because Mathlib's norm on Fin n → ℝ is the sup norm.
The method is a run predicate, IsEllipsoidRun. Every theorem holds for every admissible oracle answer. The update is the published one with a=−wt.
If an oracle answer is wt=0 (possible only at a minimizer ct∈X), the run stops. The page's update would divide by zero there.
Conventions and hypotheses added to the page:
n≥2, because the update (2.6) is defined only for n≥2.
A minimizer x∗ exists (the book's standing assumption, p. 242).
The output ranges over the queried centers c0,…,ct−1. The page writes {c1,…,ct}, but ct has not been cut yet and c0 has.
t≥1, because at R=r and t=0 no center has been queried.
A run predicate whose separation branch does not require X⊂{x:(x−ct)⊤wt≤0}, or that accepts wt=0 with an update, would make the statements false or vacuous. Both are excluded.
Lemma 2.3's volume factor is exp(−1/(2n)). The weaker published factor does not prove that milestone. The published theorem LinearOptimization.ellipsoid_update_halfspace_volume is included as a reference: it supplies the containment (2.3) and positive definiteness. Contributions are welcome on every milestone. A determinant formula for the volume of an ellipsoid would be reusable well beyond this mission.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980v2
N. Z. Shor, Cut-off method with space extension in convex programming problems, Cybernetics 13:94–96, 1977. doi:10.1007/BF01071394
D. B. Yudin and A. S. Nemirovski, Informational complexity and efficient methods for the solution of convex extremal problems, Matekon 13(2):22–45, 1976.
L. G. Khachiyan, A polynomial algorithm in linear programming, Soviet Mathematics Doklady 20:191–194, 1979.
M. Grötschel, L. Lovász and A. Schrijver, The ellipsoid method and its consequences in combinatorial optimization, Combinatorica 1:169–197, 1981. doi:10.1007/BF02579273
D. Bertsimas and J. N. Tsitsiklis, Introduction to Linear Optimization, Athena Scientific, 1997 (Theorem 8.1).
Convex Optimization: Algorithms and Complexity III: Projected Subgradient Descent with η = R/(L√t) Satisfies f(average) − f(x*) ≤ RL/√tTextbook
Motivation
Many convex optimization problems in machine learning and statistics have objectives that are convex but not differentiable: hinge losses, ℓ1 penalties, maxima of finitely many affine functions, and the dual functions of Lagrangian relaxations. Methods that rely on gradients do not apply to them directly, while cutting-plane methods such as the ellipsoid method pay a price that grows with the dimension. The projected subgradient method replaces the gradient by an arbitrary subgradient and restores feasibility by a Euclidean projection. Its guarantee depends on the dimension only through two constants, a radius R and a Lipschitz constant L. This is the reason it, and its descendants (mirror descent, stochastic gradient descent, online gradient descent), are the standard tools for large-scale nonsmooth problems.
The rate analysed here goes back to the subgradient methods of Shor and Polyak in the 1960s and 1970s and to the lower bounds of Nemirovski and Yudin (1983). The book follows the presentation of Nesterov, Introductory Lectures on Convex Optimization (2004). The strongly convex variant with weights proportional to s is from Lacoste-Julien, Schmidt and Bach (2012).
This mission is the third of a series formalizing S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015), and covers the preamble of Chapter 3, Section 3.1 and Section 3.4.1.
Setting
Let Rn carry the Euclidean inner product x⊤y and norm ∥⋅∥. Let X⊆Rn be compact and convex, and let f be a convex function on X with a minimizer x∗∈X.
A vector g is a subgradient of f at x∈X if f(x)−f(y)≤g⊤(x−y) for every y∈X. The set of subgradients at x is written ∂f(x). The projectionΠX(y) of a point y∈Rn is the point of X nearest to y.
Fix step sizes ηs>0. Projected subgradient descent starts at some x1∈X and iterates, for s≥1,
ys+1=xs−ηsgs,gs∈∂f(xs),xs+1=ΠX(ys+1).
Any subgradient may be chosen at each step. In Section 3.1 the step is constant, ηs=η. The set X lies in the Euclidean ball of radius R centred at x1, and the subgradients have norm at most L.
A function f is α-strongly convex on X if f(x)−f(y)≤g⊤(x−y)−2α∥x−y∥2 for all x,y∈X and g∈∂f(x).
Formalization targets
Goal: Theorem 3.2
For every horizon t≥1, projected subgradient descent with the constant step η=R/(Lt) satisfies
f(t1s=1∑txs)−f(x∗)≤tRL.
Milestones
Lemma 3.1. For x∈X and y∈Rn: (ΠX(y)−x)⊤(ΠX(y)−y)≤0, already on the platform as a published theorem. The mission also states its consequence
∥ΠX(y)−x∥2+∥y−ΠX(y)∥2≤∥y−x∥2.
The per-step inequality in the proof of Theorem 3.2:
If f is α-strongly convex and its subgradients are bounded by L, then with ηs=2/(α(s+1)),
f(s=1∑tt(t+1)2sxs)−f(x∗)≤α(t+1)2L2.
Significance
Theorem 3.2 gives an oracle complexity of O(R2L2/ε2) for reaching an ε-optimal point, independent of the ambient dimension. Section 3.5 of the book shows this rate is unimprovable for black-box first-order methods once the dimension is large. Theorem 3.9 shows how strong convexity improves the rate to O(1/t), with the averaging weights changed from uniform to linear. These two bounds are the reference points against which the rest of Chapter 3 and Chapters 4 to 6 (smooth, accelerated, mirror, stochastic methods) are measured.
The results are classical and their proofs are short. Formalizing them produces a reusable, machine-checked account of the basic projected first-order step: the projection inequality, the one-step distance recursion, and the telescoping argument with Jensen's inequality for averaged iterates. To our knowledge, no machine-checked proof of the averaged-iterate bound for the projected subgradient method exists in Mathlib. Related platform items cover other algorithms or other averaging schemes.
Difficulty
The arithmetic is elementary, and the obvious argument works. The care is in the bookkeeping. The projection must be shown not to increase the distance to x∗, which needs convexity of X and the variational characterization of the nearest point. The sum must telescope with a horizon-dependent constant step. Jensen's inequality must be applied to a finite convex combination of points of X, which requires showing that the average lies in X. In Theorem 3.9 the step sizes and the averaging weights are coupled, so neither can be changed independently. In Lean, the iterates are indexed from 1 with natural-number horizons, and the bounds involve t, so these casts need care.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n). The iterates are sequences ℕ → EuclideanSpace ℝ (Fin n) with the first iterate at index 1. The projection is the published relation OnlineConvexOpt.FirstOrder.IsMetricProjection (xs+1∈X is a nearest point to ys+1). Subgradients are taken relative to X (Definition 1.2). A run is a predicate on the steps s=1,…,t, and every theorem holds for all runs, that is, for every choice of subgradients. Compactness and convexity of X, convexity of f on X and the existence of the minimizer x∗ are the book's standing assumptions and appear as hypotheses. R>0, L>0 and α>0 are explicit, because Lean's division by zero would otherwise turn the step size into a junk value.
The book assumes ∥g∥≤L for every subgradient at every point of X. With subgradients relative to a compact X, that assumption can never hold at a boundary point, since every outward normal can be added to a subgradient. Stated that way the theorems would be vacuous. The mission therefore assumes the bound only for the subgradients g1,…,gt that the run uses. This is a weaker hypothesis and gives a stronger, non-vacuous statement. Bounding only these subgradients is a deliberate choice, not a trivialization: the bound still constrains every quantity the conclusion depends on.
Contributions welcome: proofs of the four inequalities and of the two rates, and a reusable lemma that the convex combination of finitely many points of a convex set lies in the set, together with Jensen's inequality in the form used here.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. https://arxiv.org/abs/1405.4980
A. Nemirovski and D. Yudin, Problem Complexity and Method Efficiency in Optimization, Wiley, 1983.
S. Lacoste-Julien, M. Schmidt and F. Bach, A simpler approach to obtaining an O(1/t) convergence rate for the projected stochastic subgradient method, 2012. https://arxiv.org/abs/1212.2002
Convex Optimization: Algorithms and Complexity IV: Gradient Descent on a Convex β-Smooth Function Has Rate 2β‖x₁ − x*‖²/(t − 1)Textbook
Motivation
Gradient descent goes back to Cauchy (1847). It is the simplest method for minimizing a differentiable function, and most of the first-order methods in large-scale optimization and machine learning are variants of it. Its appeal in high dimension is that its oracle complexity, the number of gradient evaluations needed to reach a given accuracy, can be bounded independently of the dimension. For a merely Lipschitz convex function the projected subgradient method needs on the order of 1/ε2 steps to reach accuracy ε (Theorem 3.2 of the book). Under a smoothness assumption gradient descent does much better, because the gradients shrink near the optimum and the steps adapt automatically.
This mission formalizes the basic result of that kind: Theorem 3.3 of S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning 8(3–4), 2015; arXiv:1405.4980v2). It states that gradient descent with step size 1/β on a convex β-smooth function on Rn has optimality gap O(1/t) after t steps. The result and its proof are standard; versions appear in Nesterov's Introductory Lectures on Convex Optimization (2004, §2.1.5). It is the fourth mission in a series that formalizes the capstone results of Bubeck's monograph.
Setting
Write Rn for Euclidean space with inner product x⊤y and norm ∥⋅∥. Let f:Rn→R be differentiable with gradient ∇f.
f is convex if f((1−λ)x+λy)≤(1−λ)f(x)+λf(y) for all x,y and λ∈[0,1].
For β≥0, f is β-smooth if its gradient is β-Lipschitz:
∥∇f(x)−∇f(y)∥≤β∥x−y∥for all x,y∈Rn.
A minimizer is a point x∗ with f(x∗)≤f(y) for every y. Throughout the book a minimizer is assumed to exist.
Gradient descent with step size η>0, started at x1∈Rn, is the sequence
xt+1=xt−η∇f(xt),t≥1.(3.1)
The optimality gaps are δs=f(xs)−f(x∗)≥0.
Formalization targets
Goal: Theorem 3.3 (p. 267)
If f is convex and β-smooth with β>0, x∗ is a minimizer, and (xt) is gradient descent with η=1/β, then for every t≥2
f(xt)−f(x∗)≤t−12β∥x1−x∗∥2.
Milestones
These are the statements the book's proof uses, in the book's order:
Lemma 3.4 (p. 267). For any β-smooth f, with no convexity: ∣f(x)−f(y)−∇f(y)⊤(x−y)∣≤2β∥x−y∥2.
(3.4) (p. 267). For convex β-smooth f: 0≤f(x)−f(y)−∇f(y)⊤(x−y)≤2β∥x−y∥2.
(3.5) (p. 267). For convex f, one step of length 1/β decreases f by at least 2β1∥∇f(x)∥2.
Lemma 3.5 (p. 268). If (3.4) holds, then f(x)−f(y)≤∇f(x)⊤(x−y)−2β1∥∇f(x)−∇f(y)∥2.
Distances decrease (proof of Theorem 3.3, p. 269). ∥xs+1−x∗∥≤∥xs−x∗∥ for every s≥1.
The recursion (p. 268). δs+1≤δs−2β∥x1−x∗∥21δs2.
From the recursion to the rate (p. 269). For ω>0 and non-negative reals, ωδs2+δs+1≤δs for all s≥1 implies 1/δt≥ω(t−1).
Stronger companion: footnote 4 (p. 269)
Under the same hypotheses, f(xt)−f(x∗)≤2β∥x1−x∗∥2/(t+3) for every t≥1.
Significance
Theorem 3.3 is the reference rate for first-order methods on smooth convex problems. Several later results in the book are measured against it. Nesterov's accelerated gradient descent (§3.7) improves 1/t to 1/t2, the lower bounds of §3.5 show that 1/t2 cannot be beaten by any black-box first-order method, and adding strong convexity (§3.4) upgrades 1/t to a linear rate. Its ingredients are reused throughout the book and the optimization literature: the descent lemma (Lemma 3.4), the one-step improvement (3.5) and co-coercivity (3.6). Co-coercivity is the finite-dimensional case of the Baillon–Haddad theorem.
The result is classical and fully proved on paper. To our knowledge Mathlib does not contain this rate for gradient descent on convex smooth functions, and no published Prove2Me theorem states it. The mission provides it, together with Lemma 3.4 and co-coercivity as reusable statements on EuclideanSpace ℝ (Fin n). These are the facts that later missions of the series on projected gradient descent, strong convexity and acceleration need. Formalizing the improved constant of footnote 4 is a welcome addition.
Difficulty
Two steps are not routine. The first is Lemma 3.4, where the book integrates the gradient along a segment. In Lean this needs a mean-value or fundamental-theorem-of-calculus argument for a function on a Euclidean space, together with a Cauchy–Schwarz estimate, and Mathlib's HasGradientAt interface has to be connected to one-variable derivatives along lines.
The second is the monotonicity of ∥xs−x∗∥. The natural first attempt is to telescope the one-step improvement (3.5) together with the convexity bound δs≤∥xs−x∗∥∥∇f(xs)∥. That gives a recursion involving ∥xs−x∗∥, which is not controlled by ∥x1−x∗∥ without further work. Making the recursion uniform requires co-coercivity (3.6), which comes from Lemma 3.5. That lemma's hypothesis is the two-sided inequality (3.4), not smoothness directly. The final numerical step divides by the gaps δs, so zero gaps need separate handling.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n), and x⊤y is ⟪x, y⟫_ℝ.
The gradient is an explicit map g:Rn→Rn with the hypothesis ∀ x, HasGradientAt f (g x) x.
β-smoothness (IsBetaSmooth f g β) is the book's definition: β≥0, the gradient-existence hypothesis, and the Lipschitz bound ∥g(x)−g(y)∥≤β∥x−y∥. The book's "continuously differentiable" follows from it.
Convexity is Mathlib's ConvexOn ℝ Set.univ f. A minimizer is a point xstar with ∀ y, f xstar ≤ f y; its existence is the book's standing assumption, and ∇f(x∗)=0 is derived, not assumed.
A gradient-descent run (IsGDRun g η x) is a sequence x : ℕ → ℝⁿ with η>0 and xt+1=xt−ηg(xt) for every t≥1. The book's x1 is x 1, and index 0 is unused. Every theorem quantifies over all runs with η=1/β.
Disclosed side conditions:
β>0 wherever the page divides by β. Convexity is retained for (3.5), as in its source context.
t≥2 in the goal, where the page's bound has denominator t−1.
Statements in which the page divides by δs or by ∥x1−x∗∥2 are multiplied through, so that they stay true and meaningful when those quantities vanish.
A trivializing formalization is ruled out. Smoothness is the Lipschitz condition on the gradient, so Lemma 3.4 and (3.4) are not restatements of the definition, as they would be if the quadratic upper bound (3.4) were taken as the definition of smoothness. The run predicate also fixes the step size 1/β.
A complete development needs:
the segment integral or mean-value estimate for HasGradientAt functions;
first-order characterizations of convexity for differentiable functions;
elementary inner-product algebra.
Lemma 3.4, Lemma 3.5 and (3.6) are reusable well beyond this mission. Proofs of any milestone are welcome independently.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–357, 2015. arXiv:1405.4980v2; §3.2, pp. 266–269.
A. Cauchy, Méthode générale pour la résolution des systèmes d'équations simultanées, C. R. Acad. Sci. Paris 25:536–538, 1847.
Y. Nesterov, Introductory Lectures on Convex Optimization: A Basic Course, Kluwer, 2004. doi:10.1007/978-1-4419-8853-9
J.-B. Baillon and G. Haddad, Quelques propriétés des opérateurs angle-bornés et n-cycliquement monotones, Israel J. Math. 26:137–150, 1977. doi:10.1007/BF03007664
Convex Optimization: Algorithms and Complexity V: Projected Gradient Descent on a Convex β-Smooth Function Has Rate (3β‖x₁ − x*‖² + f(x₁) − f(x*))/tTextbook
Motivation
Many optimization problems in statistics, machine learning and operations research ask to minimize a smooth convex function over a simple convex set: a box, a ball, a simplex, a cone of positive semidefinite matrices. Projected gradient descent is the most basic first-order method for such problems. It takes a gradient step and then returns to the feasible set by Euclidean projection. Its cost per iteration is one gradient evaluation and one projection, independent of the dimension apart from the cost of manipulating vectors, which is why it remains a workhorse in very high dimension.
This mission is the fifth in a series formalizing S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning 8(3–4), 2015; arXiv:1405.4980). Chapter 3 of the monograph treats "dimension-free" convex optimization. Its §3.2 first proves that gradient descent on a convex β-smooth function on Rn has rate O(β∥x1−x∗∥2/t) (Theorem 3.3, the subject of mission IV), and then turns to the constrained case, which is the subject of this mission. The analysis follows Nesterov's Introductory Lectures on Convex Optimization (2004).
Setting
Write x⊤y for the Euclidean inner product on Rn and ∥⋅∥ for the Euclidean norm. The constraint setX⊆Rn is compact and convex; this is the standing assumption of Chapter 3. The Euclidean projection of y∈Rn onto X is
ΠX(y)=z∈Xargmin∥y−z∥,
which exists and is unique for a nonempty closed convex set.
A differentiable function f:Rn→R is β-smooth on X if its gradient is β-Lipschitz there:
∥∇f(x)−∇f(y)∥≤β∥x−y∥(x,y∈X).
It is α-strongly convex on X if f(x)−f(y)≤∇f(x)⊤(x−y)−2α∥x−y∥2 for x,y∈X. A minimizerx∗∈X of f over X is assumed to exist, as everywhere in the monograph.
Projected gradient descent with step size η=1/β starts at x1∈X and iterates
xt+1=ΠX(xt−β1∇f(xt))(t≥1).
For a point x with projected step x+=ΠX(x−β1∇f(x)), the gradient mapping is gX(x)=β(x−x+). Without constraints it equals ∇f(x).
Formalization targets
Goal: Theorem 3.7 (p. 270)
For f convex and β-smooth on X, projected gradient descent with η=1/β satisfies, for every t≥1,
f(xt)−f(x∗)≤t3β∥x1−x∗∥2+f(x1)−f(x∗).
Milestones
Lemma 3.1 (p. 263): for x∈X and y∈Rn, (ΠX(y)−x)⊤(ΠX(y)−y)≤0, and hence ∥ΠX(y)−x∥2+∥y−ΠX(y)∥2≤∥y−x∥2. The first claim is an already proved platform theorem.
(3.7) (p. 270): ∇f(x)⊤(x+−y)≤gX(x)⊤(x+−y) for y∈X.
Lemma 3.6 (p. 270): for x,y∈X,
f(x+)−f(y)≤gX(x)⊤(x−y)−2β1∥gX(x)∥2.
Descent and gap (pp. 270–271): f(xs+1)−f(xs)≤−2β1∥gX(xs)∥2 and f(xs+1)−f(x∗)≤∥gX(xs)∥∥xs−x∗∥.
Distances decrease (p. 271): ∥xs+1−x∗∥≤∥xs−x∗∥.
Recursion and induction (p. 271): with δs=f(xs)−f(x∗), δs+1≤δs−2β∥x1−x∗∥21δs+12, and an induction on this recursion gives the bound of Theorem 3.7.
Companion: Theorem 3.10 (p. 278)
If f is in addition α-strongly convex on X, with condition number κ=β/α, then the strengthened Lemma 3.6, display (3.14), gives for every t≥0
∥xt+1−x∗∥2≤exp(−κt)∥x1−x∗∥2.
Significance
Theorem 3.7 shows that a constraint set with a cheap projection costs nothing in the order of convergence: the O(β∥x1−x∗∥2/t) rate of unconstrained gradient descent survives, with a constant that depends on f(x1)−f(x∗). Lemma 3.6 is the reusable part. It isolates the gradient mapping as the quantity that measures progress under constraints, and the same inequality, with a strong-convexity term added, gives the linear rate of Theorem 3.10. It is also the starting point of the analysis of proximal gradient methods for composite objectives.
All of these results are classical and proved in the textbook. As far as a search of the platform shows, none of them is formalized there. A related platform theorem on constrained gradient descent for well-conditioned functions (from Hazan's Introduction to Online Convex Optimization) bounds function values with a different exponent. It is not Theorem 3.10, which bounds distances with rate exp(−t/κ). This mission adds machine-checked statements of the constrained analysis in Bubeck's formulation, with the book's constants. The definitions of β-smoothness on a set, the gradient mapping and the run predicate can be reused by later missions on accelerated and proximal methods.
Difficulty
The obvious attempt is to copy the unconstrained proof, which rests on the descent inequality f(x−β1∇f(x))≤f(x)−2β1∥∇f(x)∥2. That inequality fails under constraints: the projection can cut the step short, so the decrease in f is not controlled by ∥∇f(x)∥. At a boundary minimizer, for instance, ∇f(x∗)=0 while no step makes progress. The proof has to replace the gradient by the gradient mapping throughout. It also has to show separately that the iterates do not move away from x∗, a fact that came for free without constraints from co-coercivity of the gradient (display (3.6)).
The closing induction is not routine either. The step from s to s+1 works only from s=2 on, and the step from 1 to 2 needs a direct computation that uses the term f(x1)−f(x∗) in the numerator.
Formalization scope
Space.Rn is EuclideanSpace ℝ (Fin n), and x⊤y is ⟪x, y⟫_ℝ.
Constraint set and minimizer. Every statement assumes X compact (IsCompact X) and convex (Convex ℝ X), the standing assumption of Chapter 3. Every statement about a run assumes a minimizer x∗∈X with f(x∗)≤f(y) for all y∈X, the monograph's standing assumption.
Gradient. The gradient is an explicit map g with HasGradientAt f (g x) x at every point of Rn, so ∇f(x) is defined at boundary points of X. β-smoothness on X (IsBetaSmoothOn X f g β) asks this together with β≥0 and the Lipschitz bound on X only. It is not the quadratic upper bound (3.4), which is a consequence.
Strong convexity. It is the published predicate OnlineConvexOpt.ConvexBasics.StronglyConvexOn X f g α, which is display (3.13) with the same gradient map. Display (3.14) and Theorem 3.10 use α>0.
Projection. The projection is the published relation IsMetricProjection X y p: p∈X and ∥y−p∥≤∥y−z∥ for every z∈X. No choice function is used.
Run. A run is IsProjGDRun X g β x: β>0, x1∈X, and for every t≥1 the iterate xt+1 is a projection of xt−β−1g(xt). Indices start at 1 as in the book, and x 0 is unused.
Gradient mapping.gradMap β x xplus=β(x−x+) takes the projected point of the run as an argument.
Positivity.β>0 is assumed, as the step size 1/β requires, and α>0 for Theorem 3.10, as κ=β/α requires.
The recursion. The recursion of milestone 6 is stated multiplied by 2β∥x1−x∗∥2, so the case x1=x∗ needs no division.
No trivial readings. A run predicate with a free step size, or β-smoothness replaced by the quadratic bound (3.4), would change the content. Both are excluded: the step is fixed to 1/β, and smoothness is the Lipschitz condition on the gradient.
Contributions are welcome on any milestone. Lemma 3.1 and (3.7) need only the variational characterization of the projection. Lemma 3.6 needs the quadratic upper bound for a function whose gradient is Lipschitz on a convex set, together with the first-order characterization of convexity relative to a set. Both are of independent use. The induction milestone is a self-contained statement about real sequences.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980
Y. Nesterov, Introductory Lectures on Convex Optimization: A Basic Course, Kluwer Academic Publishers, 2004. doi:10.1007/978-1-4419-8853-9
E. Hazan, Introduction to Online Convex Optimization, 2nd ed., MIT Press, 2022. arXiv:1909.05207
Convex Optimization: Algorithms and Complexity VI: Gradient Descent with η = 2/(α + β) on a β-Smooth α-Strongly Convex Function Has Rate (β/2)exp(−4t/(κ + 1))‖x₁ − x*‖²Textbook
Motivation
Gradient descent is a basic method for minimizing a differentiable function when evaluating its gradient is practical but solving the optimization problem directly is not. The rate at which its iterates approach an optimizer depends on the assumptions about the function. For a convex function with a Lipschitz gradient, the value error decreases at a sublinear rate. Adding strong convexity changes the behavior: the distance from the optimizer contracts at each step, giving an exponential bound on the value error. This section of Bubeck's monograph identifies a fixed step size that uses both the smoothness and curvature constants and gives the corresponding rate.
The result matters when a high-accuracy answer is needed. A sublinear bound makes each extra digit progressively more expensive; an exponential bound says that a fixed number of additional gradient evaluations reduces the error by a fixed factor. The theorem is a textbook result, already proved mathematically. This mission asks for its precise machine-checked statement and the source's supporting inequalities, rather than for a new optimization method.
Setting
Work in Euclidean space Rn with n≥1, equipped with its usual inner product and norm. A differentiable function f:Rn→R has gradient g(x)=∇f(x). It is β-smooth when its gradient is β-Lipschitz: ∥g(x)−g(y)∥≤β∥x−y∥ for every x,y. It is α-strongly convex when, for every x,y,
f(y)≥f(x)+⟨g(x),y−x⟩+2α∥y−x∥2.
The first condition limits how rapidly the gradient changes. The second gives a quadratic lower bound on the function around any point. Here α>0 and β≥0. In positive dimension, the two conditions together entail β≥α, so the condition numberκ=β/α is at least one. The case α=β remains part of the target.
A point x∗ is a global minimizer when f(x∗)≤f(y) for every y. The book assumes such a point exists as a standing convention. A gradient descent run is a sequence (xt)t≥1 satisfying xt+1=xt−ηg(xt) at each positive index. Its first iterate x1 is arbitrary. The step size in this mission is fixed at η=2/(α+β), rather than chosen by line search or adapted along the run.
Formalization targets
The central target is Theorem 3.12 of Bubeck, p. 279. For every integer t≥0, the gradient descent run satisfies
f(xt+1)−f(x∗)≤2βexp(−κ+14t)∥x1−x∗∥2.
At t=0 this is a smoothness bound on the initial value gap. For subsequent iterations it gives a linear convergence rate with the explicit exponential factor stated in the book. No initial-radius bound or bounded domain is imposed: the actual squared distance ∥x1−x∗∥2 appears in the conclusion.
The milestones trace the mathematical claims stated in the source. Equation (3.6) is the co-coercivity inequality for gradients of convex smooth functions. The proof of Lemma 3.11 introduces ϕ(z)=f(z)−(α/2)∥z∥2, and identifies it as convex and (β−α)-smooth. Lemma 3.11 combines curvature and smoothness into a sharper inequality for two gradients. The proof of Theorem 3.12 then gives a value-gap bound, a one-step distance contraction, and its iterated exponential form. These statements are separately useful: the co-coercivity and contraction bounds can be reused in analyses of related first-order methods.
Significance
The theorem states a complete guarantee for the algorithm: an explicit rule, the hypotheses on the objective, and a bound valid for every iteration count. It makes the role of κ visible. When κ is close to one, the contraction is strong; when the smoothness constant is much larger than the curvature constant, more iterations are needed for the same error reduction. The stated dependence supports comparisons with projected and accelerated gradient methods elsewhere in the same monograph.
Formalizing the result requires a common interface for actual gradients, smoothness, strong convexity, and algorithm runs. The strong-convexity predicate is an existing published definition, while the local smoothness and run definitions use Bubeck's conventions. Once these interfaces and the inequalities are proved, later missions can use the resulting declarations to compare rates without translating between informal meanings of “smooth” or changing the iterate index. The source provides a mathematical proof; these draft Lean theorems carry sorry and do not yet constitute machine-checked proofs.
Difficulty
The main issue is getting the sharp contraction factor from two assumptions that control different parts of the gradient step. A direct Lipschitz estimate on the update map does not by itself express the mixed inner-product term with the constants needed for the stated factor. Lemma 3.11 is the source's precise bridge between the gradient difference, the point displacement, and their inner product. The case α=β also needs to remain valid: a proof route that divides by β−α cannot cover that boundary by the same calculation.
The last display in the proof of Theorem 3.12 joins a one-step inequality involving xt to an exponential inequality involving x1. The latter is the cumulative statement after t steps. Keeping these as separate milestones makes each quantified claim explicit while preserving the theorem's bound.
Formalization scope
Lean represents Rn as EuclideanSpace ℝ (Fin n), with n>0. The gradient is an explicit map g required to be the actual gradient of f at every point. Smoothness is the gradient Lipschitz condition, not a quadratic upper bound used as a definition. Strong convexity uses the published OnlineConvexOpt.ConvexBasics.StronglyConvexOn predicate on the whole space; its formula is the book's (3.13). Iterates are indexed from one, and index zero imposes no condition. The norm, inner product, constants, and real exponential follow the printed formulas.
The added explicit conditions are n>0, α>0, and β>0 where Equation (3.6) divides by β. Positive dimension excludes a degenerate space where curvature imposes no restriction on smoothness. The positivity of α makes κ meaningful; the source treats it as a positive strong-convexity parameter. The minimizer hypothesis is the book's standing convention. There is no assumption that g(x∗)=0: that property follows from global minimality and differentiability. A gradient map unrelated to f would trivialize the model, so the smoothness definition includes the gradient identity.
The local development needs Euclidean inner-product identities, convexity, differentiability, Lipschitz gradient bounds, and real exponential estimates. The auxiliary function and the two co-coercivity inequalities are reusable outside this chapter. Contributions should prove the exact milestone statements and the final theorem, including t=0 and α=β, without weakening constants or substituting another gradient descent step.
Selected references
Sébastien Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980v2; DOI:10.1561/2200000050.
Convex Optimization: Algorithms and Complexity VII: Conditional Gradient Descent (Frank–Wolfe) with γ_s = 2/(s + 1) Has Rate 2βR²/(t + 1) in Any NormTextbook
Motivation
Many constrained optimization problems in machine learning and statistics have a feasible set X over which a linear function is cheap to minimize but a Euclidean projection is expensive: the ℓ1-ball, the simplex, the nuclear-norm ball, the convex hull of a combinatorial family. Projected gradient descent needs a projection at every step. Conditional gradient descent, introduced by Frank and Wolfe in 1956 for quadratic programming, replaces the projection by a call to a linear minimization oracle over X, and its iterates are convex combinations of oracle outputs, which makes them sparse when X is a polytope.
This mission is the seventh of a series formalizing S. Bubeck's monograph Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015, arXiv:1405.4980v2). It covers Section 3.3, whose main result, Theorem 3.8, is the O(1/t) rate of the method in the form given by Jaggi (2013), going back to Dunn and Harshbarger (1978).
Setting
Let E be a finite-dimensional real vector space with an arbitrary norm∥⋅∥. For a linear form g on E, written v↦g⊤v, the dual norm is ∥g∥∗=sup∥v∥≤1g⊤v. Let X⊆E be nonempty, compact and convex, with diameterR=supx,y∈X∥x−y∥.
Let f:E→R be differentiable with gradient ∇f(x), a linear form on E. For β≥0, f is β-smooth with respect to ∥⋅∥ on X if
∥∇f(x)−∇f(y)∥∗≤β∥x−y∥(x,y∈X).
A point x∗∈X with f(x∗)=minx∈Xf(x) is fixed throughout, and δt=f(xt)−f(x∗).
Given step sizes (γs)s≥1, a run of conditional gradient descent is a pair of sequences with x1∈X and, for every t≥1,
The minimizer yt need not be unique; any choice is allowed.
Formalization targets
Goal: Theorem 3.8 (p. 272)
If f is convex and β-smooth with respect to ∥⋅∥ and γs=s+12 for s≥1, then every run satisfies, for every t≥2,
f(xt)−f(x∗)≤t+12βR2.
Milestones
Inequality (3.4) in an arbitrary norm (p. 267, used on p. 272): for x,y∈X, 0≤f(x)−f(y)−∇f(y)⊤(x−y)≤2β∥x−y∥2.
The one-step recursion (pp. 272–273): for any run with γs∈[0,1],
δs+1≤(1−γs)δs+2βγs2R2.
Initialization (p. 273): if γ1=1, then δ2≤2βR2.
The induction (p. 273): a real sequence with δ2≤2βR2 and the recursion of milestone 2 with γs=s+12 for s≥2 satisfies δt≤t+12βR2 for t≥2.
Significance
Theorem 3.8 is the basic guarantee for projection-free first-order optimization. Its rate does not depend on the dimension, and it depends on the geometry only through the product βR2, both measured in the same norm, which may be chosen to fit X: for the ℓ1-ball, smoothness in ∥⋅∥1 with dual norm ∥⋅∥∞ gives much better constants than the Euclidean analysis. The book applies it this way to a LASSO-type problem (Section 3.3, pp. 274–276), and the same bound underlies the sparse-approximation corollary on the simplex (p. 273) and the many later variants of the method (away steps, stochastic and online conditional gradient).
The result is classical and proved in the book. What this mission adds is a machine-checked statement and proof in an arbitrary finite-dimensional normed space, with the dual norm as the operator norm on linear forms, and a reusable encoding of norm-smoothness and of conditional gradient runs. On Prove2Me a related result is already proved: Lan's Theorem 7.1 (First-order and Stochastic Optimization Methods), which bounds f(yk)−f∗ by k(k+1)2L∑i≤k∥xi−yi−1∥2 with a different indexing; after the diameter bound it yields 2βR2/t at Bubeck's iterate xt, which is weaker than Theorem 3.8 by one step.
Difficulty
The difficulty is in the bookkeeping of norms and indices, not in a deep idea. Inequality (3.4) is proved in the book only for the Euclidean norm, where ∇f(x)∈Rn and the Cauchy–Schwarz inequality is used; in a general norm it needs the pairing between a linear form and a vector and the bound ∣g⊤v∣≤∥g∥∗∥v∥. The rate 2βR2/(t+1) is attained only by starting the induction at t=2, where the step γ1=1 erases the dependence on the starting point; at t=1 the bound can fail, since δ1 is arbitrary. A first attempt that runs the induction from t=1 with an arbitrary δ1 does not give the stated constant.
Formalization scope
E is a type with [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]; nothing is specialised to the Euclidean norm. The gradient is an explicit derivative map f' : E → (E →L[ℝ] ℝ) with HasFDerivAt f (f' x) x for every x; ∇f(x)⊤v is f' x v, and ∥⋅∥∗ is the operator norm, which equals sup∥v∥≤1g⊤v. R is Metric.diam X, which equals the supremum of ∥x−y∥ over X because X is compact. Sequences are indexed by ℕ with the first iterate at index 1.
Committed conventions: X compact, convex and containing x∗ (hence nonempty); convexity of f and the Lipschitz bound on the gradient are assumed on X only, which is weaker than the book's global assumptions; β≥0; the existence of the minimizer x∗ is the book's standing assumption (p. 242); the conclusion is stated for t≥2, as in the book. Runs are predicates: yt is any minimizer of the linear form over X and yt∈X is required, so the goal quantifies over every run with γs=2/(s+1). A formalization in which yt need not lie in X, or in which smoothness is assumed only along the iterates, states a different theorem and is excluded.
A complete development needs the descent inequality (3.4) for Fréchet derivatives in a normed space (reusable for every smooth method in the series and beyond), the fact that the iterates stay in X, and a scalar induction. Proofs of the milestones are welcome independently; milestone 4 is a statement about real sequences only.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. https://arxiv.org/abs/1405.4980
M. Frank and P. Wolfe, An algorithm for quadratic programming, Naval Research Logistics Quarterly 3(1–2):95–110, 1956. https://doi.org/10.1002/nav.3800030109
J. C. Dunn and S. Harshbarger, Conditional gradient algorithms with open loop step size rules, Journal of Mathematical Analysis and Applications 62(2):432–444, 1978. https://doi.org/10.1016/0022-247X(78)90137-3
Convex Optimization: Algorithms and Complexity VIII: No Black-Box Method Beats 3β‖x₁ − x*‖²/(32(t + 1)²) on β-Smooth Convex FunctionsTextbook
Why lower bounds for first-order methods
Upper bounds for an optimization method say how fast it converges; oracle complexity lower bounds say how fast any method of a given kind can possibly converge. Chapter 3 of S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning 8(3–4), 2015, arXiv:1405.4980) proves upper bounds for subgradient descent on Lipschitz functions and for gradient methods on smooth functions. Section 3.5 (Lower bounds, pp. 279–283) shows that these rates cannot be improved by more than a numerical constant, as long as the number of queries is smaller than the dimension. For smooth convex functions the matching lower bound is what identifies Nesterov's accelerated gradient descent, with its 1/t2 rate, as an optimal method.
Timeline. The lower bounds first appeared in A. Nemirovski and D. Yudin, Problem Complexity and Method Efficiency in Optimization (Wiley, 1983). The presentation followed by the book, with an explicit tridiagonal quadratic as the hard instance and the "span of past gradients" restriction on the method, is that of Y. Nesterov, Introductory Lectures on Convex Optimization (Kluwer, 2004), §2.1.2. Nesterov's accelerated method (1983) attains the matching upper bound.
Setting
Work in Rn with the Euclidean inner product x⊤y, coordinates x(1),…,x(n), canonical basis e1,…,en and balls B2(R)={x:∥x∥≤R}. A first-order oracle for f answers a query x with a subgradient g∈∂f(x) (the gradient when f is differentiable). A black-box procedure maps the history (x1,g1,…,xt,gt) to the next query xt+1. Section 3.5 restricts attention to procedures with
x1=0,xt+1∈Span(g1,…,gt)(t≥0),(3.15)
which covers gradient descent, its accelerated variants and conjugate gradient. A function is β-smooth if its gradient is β-Lipschitz; L-Lipschitz on X if every subgradient at every point of X has norm at most L; α-strongly convex if x↦f(x)−2α∥x∥2 is convex.
The hard smooth instance uses, for k≤n, the symmetric tridiagonal matrix Ak with entries 2 on the first k diagonal positions and −1 on the neighbouring off-diagonal positions of the leading k×k block, zero elsewhere, and the quadratics
fk(x)=8βx⊤Akx−4βx⊤e1,fk∗=x∈Rninffk(x).
Formalization targets
Goal: Theorem 3.14 (p. 282)
For 1≤t≤2n−1 and β>0 there are a β-smooth convex f and a minimizer x∗ such that every procedure satisfying (3.15) has
1≤s≤tminf(xs)−f(x∗)≥323β(t+1)2∥x1−x∗∥2.
The constant 3/32 is the book's.
Milestones (proof of Theorem 3.14, pp. 282–283)
0⪯Ak⪯4In, through x⊤Akx=x(1)2+x(k)2+∑i=1k−1(x(i)−x(i+1))2.
For f=f2t+1 and any procedure satisfying (3.15), xs∈Span(e1,…,es−1); hence f(xs)=fs(xs) for s≤t.
xk∗(i)=1−k+1i solves Akx=e1, minimizes fk, and fk∗=−8β(1−k+11).
For 1≤t≤n and L,R>0 there are a convex f, L-Lipschitz on B2(R), and a first-order oracle for it such that every procedure satisfying (3.15) has mins≤tf(xs)−minB2(R)f≥2(1+t)RL; and for α>0 there are an α-strongly convex f, L-Lipschitz on B2(2αL), and an oracle with gap at least 8αtL2 over that ball.
Significance
The upper bounds of Chapter 3 (projected subgradient descent at rate RL/t, accelerated gradient descent at rate β∥x1−x∗∥2/t2) become optimal statements only through these lower bounds: no method in the class (3.15) can be faster by more than a constant factor while t is below the dimension. The restriction to t≲n is necessary, since Chapter 2's cutting-plane methods converge exponentially once the number of queries exceeds the dimension.
The results are classical and proved. Formalizing them yields machine-checked versions of the quadratic-form computation for the tridiagonal matrix, of the Krylov-type support argument under (3.15), and of the explicit minimizer of fk, each reusable in other lower-bound arguments (Theorem 3.15 in ℓ2, lower bounds for strongly convex smooth functions, conjugate gradient analyses). The platform held no formal statement of these oracle lower bounds when this mission was drafted.
Difficulty
Each analytic step is elementary; the difficulty is in the bookkeeping. The span argument is an induction that must track, at each step, that the gradient of a tridiagonal quadratic at a vector supported on the first s−1 coordinates is supported on the first s, and that the span hypothesis transfers this to the next query. The minimizer computation requires solving Akx=e1 on the leading block and showing that the coordinates beyond k do not affect fk. A natural first attempt, choosing the hard function after seeing the procedure, proves a much weaker statement and is excluded by the quantifier order: the function is fixed first and must defeat every procedure.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n). Coordinates in Lean are 0-based; the definitions provide the book's 1-based coordinate coord x i and basis vector basisVec n i, and the matrix tridiag n k translates book index i to Fin n index i−1. The query sequence starts at index 1. The oracle is a fixed map g, so (3.15) reads xt+1∈Span(g(x1),…,g(xt)) with x1=0. In Theorem 3.14 the oracle is the gradient, given as a map with HasGradientAt everywhere; β-smoothness is the Lipschitz bound on that map. In Theorem 3.13 the oracle is part of what is constructed, because the book's proof uses a specific "resisting" subgradient selection and the claim fails for an arbitrary one.
Committed conventions, each stated in the item's Formalization Note: the minimum over 1≤s≤t is the bound for every such s, and t≥1 is required; t≤(n−1)/2 is 2t+1≤n; the minimizer x∗ is existentially chosen together with f (the hard function has many minimizers when 2t+1<n, and the bound is false for some of them); the minimum over a ball is the bound against every point of the ball; fk∗ is the real infimum, asserted to be attained.
A formalization that let the function depend on the procedure, dropped x1=0, or took the span over gradients at points other than the queries would state a different and weaker theorem; the statements here keep f (and the oracle) before the universally quantified procedure.
Infrastructure needed: quadratic forms of explicit matrices on EuclideanSpace, gradients of quadratics, and span/support lemmas for EuclideanSpace.single-type vectors. Contributions of proofs for any milestone, and of the strongly convex ℓ2 lower bound (Theorem 3.15, not included here), are welcome.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. https://arxiv.org/abs/1405.4980
A. Nemirovski and D. Yudin, Problem Complexity and Method Efficiency in Optimization, Wiley, 1983.
Convex Optimization: Algorithms and Complexity IX: Nesterov's Accelerated Gradient Descent on a Convex β-Smooth Function Has Rate 2β‖x₁ − x*‖²/t²Textbook
Motivation
Minimizing a convex function f:Rn→R whose gradient is Lipschitz is the basic problem of first-order optimization, and it is the regime in which most large-scale methods of machine learning, signal processing and operations research are analysed. The natural method, gradient descent, reaches accuracy ε after O(1/ε) gradient evaluations. In 1983 Nesterov showed that a method using the same oracle, but combining the current and the previous iterate, reaches accuracy ε after only O(1/ε) evaluations, and that no method using only gradient information can do better by more than a constant factor. This accelerated gradient descent and its proximal variants (FISTA) are now the default fast first-order methods for smooth and composite convex problems.
This mission formalizes the accelerated rate as presented in S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015; arXiv:1405.4980v2), §3.7.2, Theorem 3.19, whose proof follows Beck and Teboulle (2009).
Timeline.
1983: Nesterov introduces the accelerated method with rate O(1/t2) for convex functions with Lipschitz gradient (Soviet Math. Dokl. 27).
1983: Nemirovski and Yudin's black-box lower bounds show that Ω(1/t2) is the best possible rate for this class (Theorem 3.14 of the book gives 3β∥x1−x∗∥2/(32(t+1)2)).
2009: Beck and Teboulle's FISTA extends the method, with the same step sequence λt, to composite problems with a simple nonsmooth term (SIAM J. Imaging Sci. 2(1)).
2008: Tseng gives a unified treatment with simpler step sizes (manuscript).
Setting
Let Rn carry the Euclidean inner product x⊤y and norm ∥⋅∥. A differentiable function f:Rn→R is β-smooth if its gradient is β-Lipschitz:
∥∇f(x)−∇f(y)∥≤β∥x−y∥(x,y∈Rn).
Assume f is convex and β-smooth with β>0, and let x∗ be a minimizer of f.
Define the step sequencesλ0=0,
λt=21+1+4λt−12(t≥1),γt=λt+11−λt.
Then λ1=1, λt≥1 for t≥1, and γt≤0. Nesterov's accelerated gradient descent for the smooth case starts from an arbitrary point x1=y1 and sets, for t≥1,
yt+1=xt−β1∇f(xt),xt+1=(1−γt)yt+1+γtyt.
The primary sequence(yt) consists of gradient steps of length 1/β; the sequence (xt), at which the gradient is queried, moves past yt+1 away from yt (since γt≤0). Write δt=f(yt)−f(x∗) for the optimality gap.
Formalization targets
Goal: Theorem 3.19
For every run of the method and every t≥1,
f(yt)−f(x∗)≤t22β∥x1−x∗∥2.
The constant 2 and the exponent 2 are those printed in the book.
Milestones
In the order of the book's proof (pp. 294–295):
Lemma 3.6, unconstrained (p. 270): f(x−β1∇f(x))−f(y)≤∇f(x)⊤(x−y)−2β1∥∇f(x)∥2 for all x,y.
Telescoped bound: δt≤2λt−12β∥u1∥2 for t≥2, with u1=λ1x1−(λ1−1)y1−x∗.
Growth of λ: λt−1≥t/2 for t≥2.
Significance
The result. Theorem 3.19 is the upper half of the statement that first-order methods on smooth convex functions have complexity Θ(β∥x1−x∗∥2/ε): together with the black-box lower bound of Theorem 3.14 it shows that the accelerated method is optimal up to a constant factor, while plain gradient descent (Theorem 3.3, rate 2β∥x1−x∗∥2/(t−1)) is not. The same potential-function argument, with the gradient step replaced by a proximal step, yields the rate of FISTA for composite objectives, and the identity λs−12=λs2−λs is the algebraic core of most later analyses of accelerated and momentum methods.
Formalizing it. The theorem is classical and fully proved on paper. What this mission adds is a machine-checked proof of the O(1/t2) rate for the exact step sequence of the book, with every intermediate inequality of the proof stated separately so that each can be closed and reused. A Lean development of accelerated gradient descent with this rate is not, to our knowledge, in Mathlib.
Difficulty
The rate does not follow from monotone decrease of f(yt), which is the engine of the analysis of plain gradient descent: the accelerated iterates are not monotone, and no single-step inequality on δt alone gives 1/t2. The proof instead tracks a weighted potential λs−12δs+2β∥us∥2 and needs three exact algebraic coincidences: the identity λs−12=λs2−λs, the completion of a square 2a⊤b−∥a∥2=∥b∥2−∥b−a∥2, and the rewriting (3.26) of the update rule, which makes consecutive potentials match exactly. In Lean the work is in this bookkeeping (vector identities in an inner-product space, a real recursion with square roots, and a telescoping sum indexed from 1), not in any deep analytic fact.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n); x⊤y is ⟪x, y⟫_ℝ.
The gradient is an explicit map g with HasGradientAt f (g x) x for every x; β-smoothness is the Lipschitz bound on g (not the quadratic upper bound (3.4), which is a consequence). Convexity is ConvexOn ℝ Set.univ f.
λ is a real sequence defined by recursion on N with λ0=0; γt=(1−λt)/λt+1 never divides by zero because λt+1≥1.
A run is a predicate on two sequences x,y:N→Rn, indexed from 1 as in the book; index 0 is unconstrained. Every theorem quantifies over all runs.
Standing assumptions: x∗ is a minimizer of f (book, p. 242); β>0 (implicit in the step 1/β) is a stated hypothesis.
The page prints the update as xt+1=(1−γs)yt+1+γtyt; the formalization uses γt in both places, as the proof's (3.26) requires. A run predicate with a fixed coefficient γs would describe a different (non-accelerated) method and is ruled out.
The goal is stated for all t≥1, including t=1, which the printed proof does not cover but which follows from (3.4). The growth bound λt−1≥t/2 is stated for t≥2, since λ0=0. The telescoping display prints δs2 for δs; the formalization uses δs.
Contributions of every kind are welcome: proofs of the λ facts and of (3.26) are pure algebra; (3.23)–(3.25) need the descent lemma for β-smooth functions and first-order convexity, both of which are reusable well beyond this mission.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980
Y. Nesterov, A method of solving a convex programming problem with convergence rate O(1/k²), Soviet Mathematics Doklady 27:372–376, 1983. mathnet
A. Beck, M. Teboulle, A fast iterative shrinkage-thresholding algorithm for linear inverse problems, SIAM J. Imaging Sciences 2(1):183–202, 2009. doi:10.1137/080716542
P. Tseng, On accelerated proximal gradient methods for convex-concave optimization, manuscript, 2008. pdf
A. Nemirovski, D. Yudin, Problem Complexity and Method Efficiency in Optimization, Wiley, 1983.
Convex Optimization: Algorithms and Complexity X: Nesterov's Accelerated Gradient Descent on a β-Smooth α-Strongly Convex Function Has Rate ((α + β)/2)‖x₁ − x*‖² exp(−(t − 1)/√κ)Textbook
Why accelerated rates matter
First-order methods, which query only function values and gradients, are the workhorse of large-scale optimization in machine learning, signal processing and operations research, because each step costs little more than one gradient evaluation. For a function that is both strongly convex and smooth, plain gradient descent converges geometrically, but the number of steps needed to reach accuracy ε scales with the condition numberκ of the problem. In 1983 Nesterov showed that a gradient method with a carefully chosen momentum term needs a number of steps proportional to κ instead, and that this is optimal for black-box first-order methods. On ill-conditioned problems, where κ is in the thousands or millions, the difference between κ and κ is the difference between practical and impractical.
This mission is the tenth of a series formalizing S. Bubeck's monograph Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015; arXiv:1405.4980v2). It covers §3.7.1, the smooth and strongly convex case of Nesterov's accelerated gradient descent, and its main result, Theorem 3.18.
Setting
Work in Rn with the Euclidean inner product x⊤y and norm ∥⋅∥. Let f:Rn→R be differentiable with gradient ∇f.
f is β-smooth if its gradient is β-Lipschitz: ∥∇f(x)−∇f(y)∥≤β∥x−y∥ for all x,y.
f is α-strongly convex (α>0) if for all x,y
f(y)≥f(x)+∇f(x)⊤(y−x)+2α∥y−x∥2.
The condition number is κ=β/α; for n≥1 one always has κ≥1.
x∗ denotes a minimizer of f on Rn.
Nesterov's accelerated gradient descent starts at an arbitrary point x1=y1 and iterates, for t≥1,
together with their centres vs (with v1=x1 and the recursion (3.21) of the book) and their minimum values Φs∗.
Formalization targets
Goal: Theorem 3.18
For every run of the method and every t≥1,
f(yt)−f(x∗)≤2α+β∥x1−x∗∥2exp(−κt−1).
Milestones, from the book's proof
(3.18): Φs+1(x)≤f(x)+(1−1/κ)s(Φ1(x)−f(x)) for all x.
(3.19): f(ys)≤minx∈RnΦs(x).
The geometric rate: f(yt)−f(x∗)≤2α+β∥x1−x∗∥2(1−1/κ)t−1.
The form Φs(x)=Φs∗+2α∥x−vs∥2 with vs given by (3.21).
The identity (3.22) for Φs+1∗.
The inequality (3.20), the inductive step of (3.19).
The coupling vs−xs=κ(xs−ys).
The geometric form in milestone 3 is slightly stronger than the goal, which follows from 1−u≤e−u.
Significance
Theorem 3.18 gives ε-accuracy after O(κlog(1/ε)) gradient evaluations. Projected gradient descent with step 1/β on the same class contracts only at the rate exp(−t/κ) (Theorem 3.10 of the book). The lower bound of Theorem 3.15 shows that no black-box first-order method can do better than ((κ−1)/(κ+1))2(t−1), so the accelerated rate is optimal up to constants. The estimate-sequence argument is the template for many later accelerated methods: proximal, stochastic and variance-reduced variants such as Katyusha, and accelerated coordinate descent.
The result is classical and fully proved on paper. No machine-checked proof of the accelerated rate for strongly convex smooth functions is known to exist in Lean's Mathlib. This mission produces one, with the estimate sequence Φs, its centres and its minimum values as reusable objects, and with every algebraic identity of the book's proof stated separately.
Difficulty
The algorithm is two lines, but its analysis is not a one-step contraction: neither ∥xt−x∗∥ nor f(yt)−f(x∗) decreases by the factor 1−1/κ at every step. A Lyapunov argument for gradient descent, applied directly to yt, gives only the rate 1−1/κ. The book obtains the rate through the auxiliary functions Φs. The inequality (3.18) is easy, but (3.19), that the minimum of Φs never drops below f(ys), depends on the exact choice of the momentum factor. It holds only through the identity vs−xs=κ(xs−ys), which ties the centre of Φs to the iterates. Formally, the obstacles are the bookkeeping of the recursive quadratics on Rn and the algebra in κ, 1/κ and 1/(ακ)=κ/β.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n). The gradient is an explicit map g with HasGradientAt f (g x) x at every point, which is part of the smoothness predicate IsBetaSmooth f g β. Strong convexity is the published definition OnlineConvexOpt.ConvexBasics.StronglyConvexOn Set.univ f g α, which is the book's (3.13).
A run of the method is a predicate IsNesterovSCRun g α β x y on two sequences indexed from 1, with x1=y1 arbitrary. Every theorem holds for every run, that is, every starting point.
κ is kappa α β = β / α. All theorems assume α>0 and β>0. The second is implied by the other hypotheses for n≥1; no hypothesis α≤β is added.
The existence of a minimizer x∗ is the book's standing assumption, written as a hypothesis.
Φs, vs and Φs∗=Φs(vs) are explicit recursive definitions. The book's Φs∗=minΦs is recovered by milestone 4, and no real infimum is used. The minimum in (3.19) is stated as f(ys)≤Φs(x) for every x.
The identities of milestones 4, 5 and 7 are algebraic and are stated without convexity or smoothness, for arbitrary sequences or runs.
Ruled out as trivializing: a run predicate that drops x1=y1 breaks (3.19) at s=1 and is not used. A minimum value Φs∗ defined through (3.22) would make that identity a tautology, so Φs∗ is defined as a value of Φs.
The definitions are local to the namespace ConvexOptAlg.NesterovStrong. β-smoothness duplicates the predicate of other missions of the series and will be merged afterwards. Contributions welcome: proofs of the milestones, and general lemmas on quadratics z↦c+2α∥z−v∥2 that the algebraic milestones need.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980v2, §3.7.1, Theorem 3.18, pp. 290–293.
Y. Nesterov, A method of solving a convex programming problem with convergence rate O(1/k²), Soviet Mathematics Doklady 27:372–376, 1983.
Y. Nesterov, Introductory Lectures on Convex Optimization: A Basic Course, Kluwer, 2004. doi:10.1007/978-1-4419-8853-9
Convex Optimization: Algorithms and Complexity XI: Mirror Descent with a ρ-Strongly Convex Mirror Map Has Rate RL√(2/(ρt))Textbook
Motivation
The projected subgradient method of Chapter 3 measures distances in the Euclidean norm, and its rate RL/t depends on the geometry only through a Euclidean radius R and a Euclidean bound L on the subgradients. For many constraint sets that occur in practice this is the wrong geometry. On the probability simplex Δn with subgradients bounded in ℓ∞, as for linear losses with bounded coefficients, the Euclidean constants make RL grow like n, while the problem itself is nearly dimension-free.
Mirror descent, introduced by Nemirovski and Yudin (1983), repairs this. The gradient step is taken in the dual space, after mapping the current point through the gradient of a strictly convex mirror mapΦ, and feasibility is restored by a projection in the Bregman divergence of Φ rather than in the Euclidean distance. Beck and Teboulle (2003, doi:10.1016/S0167-6377(02)00231-6) recast it as a nonlinear projected subgradient method and showed that with the negative entropy on the simplex its rate is O(Llogn/t). Nesterov (2009, doi:10.1007/s10107-007-0149-x) introduced dual averaging, a lazy variant that averages the subgradients in the dual space and maps back only when a primal point is needed. Both methods underlie online learning (exponential weights is mirror descent with the entropy), stochastic optimization, and saddle-point methods such as mirror prox.
This mission is the eleventh of a series formalizing S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015, arXiv:1405.4980). It covers the preamble of Chapter 4, Sections 4.1 and 4.2, and Section 4.4.
Setting
Let E be a finite-dimensional real vector space (the book's Rn) with an arbitrary norm∥⋅∥. A linear functional g on E acts on x by g⊤x and has dual norm∥g∥∗=sup∥x∥≤1g⊤x. Let X⊆E be compact and convex.
Let D⊆E be a convex open set with X⊆D and X∩D=∅. A function Φ:D→R is a mirror map if it is strictly convex and differentiable, its gradient takes every value in the dual space, and ∥∇Φ(x)∥→+∞ as x tends to the boundary of D. Its Bregman divergence is
DΦ(x,y)=Φ(x)−Φ(y)−∇Φ(y)⊤(x−y),
and the Bregman projection of y∈D is ΠXΦ(y)=argminx∈X∩DDΦ(x,y). The mirror map is ρ-strongly convex on X∩D if Φ(x)−Φ(y)≤∇Φ(x)⊤(x−y)−2ρ∥x−y∥2 for all x,y∈X∩D.
Let f be convex on X with a minimizer x∗∈X. A linear functional g is a subgradient of f at x if f(x)−f(y)≤g⊤(x−y) for all y∈X, and f is L-Lipschitz if the subgradients satisfy ∥g∥∗≤L.
Mirror descent with step η starts at x1∈argminX∩DΦ and, for t≥1, picks gt∈∂f(xt) and
Dual averaging instead sets xt∈argminx∈X∩Dη∑s=1t−1gs⊤x+Φ(x) (4.6). Let R2 bound Φ(x)−Φ(x1) over X∩D.
Formalization targets
Goal: Theorem 4.2
With η=LRt2ρ, every run of mirror descent satisfies
f(t1s=1∑txs)−f(x∗)≤RLρt2.
Milestones
The three-point identity (4.1): (∇f(x)−∇f(y))⊤(x−z)=Df(x,y)+Df(z,x)−Df(z,y).
Lemma 4.1: for x∈X∩D and y∈D, DΦ(x,ΠXΦ(y))+DΦ(ΠXΦ(y),y)≤DΦ(x,y), together with the first-order inequality that implies it.
The per-step inequality: f(xs)−f(x)≤η1(DΦ(x,xs)+DΦ(xs,ys+1)−DΦ(x,xs+1)−DΦ(xs+1,ys+1)).
The stability term: DΦ(xs,ys+1)−DΦ(xs+1,ys+1)≤(ηL)2/(2ρ).
The summed bound: ∑s=1t(f(xs)−f(x))≤DΦ(x,x1)/η+ηL2t/(2ρ).
Companion: Theorem 4.3
With η=LR2tρ, dual averaging satisfies f(t1∑s=1txs)−f(x∗)≤2RLρt2, with the two displays (4.7) and (4.8) of its proof as supporting items.
Significance
Theorem 4.2 is the basic rate of non-Euclidean first-order optimization. With the Euclidean mirror map Φ=21∥⋅∥22 it recovers the projected subgradient rate of Chapter 3; with the negative entropy on the simplex, which is 1-strongly convex for ℓ1 by Pinsker's inequality and has R2=logn, it gives L∞2logn/t, so the dependence on the dimension becomes logarithmic. The same analysis, with f replaced by a sequence of losses, is the regret bound of online mirror descent, and its per-step and stability inequalities are reused for stochastic mirror descent and mirror prox in later chapters of the book.
The results are classical and fully proved in the book. What this mission adds is a machine-checked version in a general finite-dimensional normed space, with gradients as linear functionals and the dual norm as the operator norm, for an arbitrary mirror map on an arbitrary open domain. On Prove2Me the three-point identity (4.1) is already posed, as Lemma 4.1 of the Beck–Teboulle formalization, and is reused here; a regret bound for online mirror descent with Legendre functions is proved in another library, but it is not this theorem and does not cover a domain D distinct from the whole space or a Bregman projection onto X∩D.
Difficulty
The algebra of the proof is short. The difficulty lies at the boundary of D. The minimizer x∗ may lie on ∂D, where Φ and ∇Φ are not defined; this is the typical case for the entropy on the simplex, where x∗ is often a vertex. The per-step bound holds only for comparison points x∈X∩D, so the bound at x∗ has to be recovered from points of X∩D, where no regularity of f beyond convexity on X is available. Lemma 4.1 needs the first-order optimality condition of the Bregman projection over the convex set X∩D, which is not closed. In the non-Euclidean setting the gradient step cannot be written in the primal space at all: the update (4.2) is an equation between linear functionals, and the norm and dual norm must be kept apart throughout.
Formalization scope
The space is a finite-dimensional real normed space E with an arbitrary norm; gradients and subgradients are elements of E →L[ℝ] ℝ, the dual norm is the operator norm, and ∇Φ is an explicit map Φ' with HasFDerivAt Φ (Φ' x) x on D.
The mirror map carries all three properties (i)–(iii) of the book; the standing setting (X compact convex, X⊆D, X∩D=∅) is a single predicate.
Runs are predicates over the first t steps, quantified universally: any subgradient, any yt+1 solving (4.2), any minimizer. A run whose next iterate were an arbitrary point of X∩D, rather than the Bregman projection, would make the theorem false; the projection is part of the run.
Sequences are indexed from 1; t≥1, ρ>0, L>0, R>0 and η>0 are explicit, since the step and the bound divide by them.
R2 is any upper bound of supX∩DΦ−Φ(x1) (the book's R is the least one); when the supremum is infinite the hypotheses cannot be met, as on the page.
"f is L-Lipschitz" is assumed for the subgradients the run uses. Subgradients relative to X are unbounded at boundary points of X, so the literal "every subgradient at every point" would make the hypothesis unsatisfiable.
The definitions (Bregman divergence, mirror map, Bregman projection, the two runs) are reusable by the later chapters on mirror prox and stochastic mirror descent. Proofs of any milestone, and of the general facts they need (nonnegativity of Bregman divergences, first-order optimality over a convex set that is not closed), are welcome.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980
A. Nemirovski and D. Yudin, Problem Complexity and Method Efficiency in Optimization, Wiley, 1983 (book; no DOI).
A. Beck and M. Teboulle, Mirror descent and nonlinear projected subgradient methods for convex optimization, Operations Research Letters 31(3):167–175, 2003. doi:10.1016/S0167-6377(02)00231-6
Y. Nesterov, Primal-dual subgradient methods for convex problems, Mathematical Programming 120(1):221–259, 2009. doi:10.1007/s10107-007-0149-x
Convex Optimization: Algorithms and Complexity XII: Mirror Prox on a Convex β-Smooth Function Has Rate βR²/(ρt)Textbook
Motivation
First-order methods for constrained convex optimization are usually analysed in the Euclidean norm, where gradient descent and its projected and accelerated variants have well-understood rates. Many constraint sets of practical interest, such as the probability simplex, the ℓ1 ball and the spectrahedron, are poorly adapted to the Euclidean geometry: the Euclidean diameter and the Euclidean Lipschitz or smoothness constants grow with the dimension. Mirror descent, due to Nemirovski and Yudin, replaces the Euclidean step by a step taken in the dual space through a mirror mapΦ, so that the rate depends on constants measured in a norm matched to the set. For non-smooth Lipschitz functions it attains the rate 1/t (Theorem 4.2 of the source, the subject of the previous mission of this series).
For smooth functions, a rate of order 1/t is available in any geometry by an extragradient-type modification. Mirror prox was introduced by Nemirovski in 2004 (Prox-method with rate of convergence O(1/t)) for variational inequalities with Lipschitz monotone operators and convex–concave saddle-point problems. It is the basis of smoothing approaches to non-smooth optimization and of stochastic saddle-point methods. This mission formalizes the version for minimizing a single smooth convex function, Theorem 4.4 of S. Bubeck, Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015), §4.5.
Setting
Fix an arbitrary norm ∥⋅∥ on a finite-dimensional real space E. Gradients are linear functionals on E; for a functional g write g⊤v for its value at v, and ∥g∥∗=sup∥v∥≤1g⊤v for the dual norm. Let X⊆E be compact and convex.
The Bregman divergence of a differentiable Φ is DΦ(x,y)=Φ(x)−Φ(y)−∇Φ(y)⊤(x−y).
Let D be a convex open set with X⊆D and X∩D=∅. A mirror map on D is a function Φ that is strictly convex and differentiable on D, whose gradient takes every value (∇Φ(D) is the whole dual space), and whose gradient norm tends to +∞ at the boundary of D.
The Bregman projection of y∈D is ΠXΦ(y)=argminx∈X∩DDΦ(x,y).
Φ is ρ-strongly convex on X∩D if Φ(x)−Φ(y)≤∇Φ(x)⊤(x−y)−2ρ∥x−y∥2 there; f is β-smooth on X if ∥∇f(x)−∇f(y)∥∗≤β∥x−y∥ for x,y∈X.
The first half is a mirror descent step from xt to yt+1; the second restarts from xt with the gradient evaluated at yt+1.
Formalization targets
Goal: Theorem 4.4
With η=ρ/β, x1∈argminX∩DΦ, R2≥supx∈X∩DΦ(x)−Φ(x1), f convex and β-smooth and x∗ a minimizer of f on X, for every t≥1
f(t1s=1∑tys+1)−f(x∗)≤ρtβR2.
Milestones
Lemma 4.1 (Bregman projections): (∇Φ(ΠXΦ(y))−∇Φ(y))⊤(ΠXΦ(y)−x)≤0 and DΦ(x,ΠXΦ(y))+DΦ(ΠXΦ(y),y)≤DΦ(x,y) for x∈X∩D, y∈D.
First term: η∇f(yt+1)⊤(xt+1−x)≤DΦ(x,xt)−DΦ(x,xt+1)−DΦ(xt+1,xt).
Second term, (4.9): η∇f(xt)⊤(yt+1−xt+1)≤DΦ(xt+1,xt)−2ρ∥xt+1−yt+1∥2−2ρ∥yt+1−xt∥2.
Third term: (∇f(yt+1)−∇f(xt))⊤(yt+1−xt+1)≤2β∥yt+1−xt∥2+2β∥yt+1−xt+1∥2.
Per-step bound: f(yt+1)−f(x)≤(DΦ(x,xt)−DΦ(x,xt+1))/η for x∈X∩D.
The three-point identity (4.1), (∇f(x)−∇f(y))⊤(x−z)=Df(x,y)+Df(z,x)−Df(z,y), is already posed on the platform as BeckTeboulleMD.EMDA.lemma_4_1 and is included by reference.
Significance
Theorem 4.4 shows that the 1/t rate of gradient descent on smooth functions survives in non-Euclidean geometries, with the dimension entering only through R2/ρ. With the negative entropy on the simplex, R2/ρ is of order logn for the ℓ1 norm, against a polynomial dependence for Euclidean methods. Beyond this single-function version, the same three-term argument is the core of the analysis of mirror prox for monotone variational inequalities and saddle-point problems (§4.6 and §5.2 of the source), where it gives the 1/t rate for smooth convex–concave games.
The result is proved in the source and in Nemirovski's paper. As far as this mission is aware it has no machine-checked proof; Mathlib has no Bregman divergences, mirror maps or mirror-descent-type algorithms. A formal proof would supply reusable infrastructure: the Bregman projection lemma (Lemma 4.1) and the three-point identity are used by every mirror-descent analysis, including the stochastic and online variants later in the source.
Difficulty
The obvious argument for mirror descent bounds f(xt)−f(x) by ∇f(xt)⊤(xt−x) and leaves a stability term of size η2∥∇f∥∗2, which yields only 1/t. Smoothness has to be used to cancel that term, and a single gradient step does not do so in a general norm. Mirror prox evaluates the gradient at the extrapolated point yt+1; the analysis must show that the error created by using ∇f(xt) for the first step is paid for by the strong convexity of Φ, which requires splitting ∇f(yt+1)⊤(yt+1−x) into three terms and bounding each with matching constants.
In Lean the difficulty is in the infrastructure: first-order optimality of a Bregman projection over X∩D, which need not be closed; the passage from x∈X∩D to a minimizer x∗ that may lie on the boundary of D; and Jensen's inequality for the average of the ys+1.
Formalization scope
E is a finite-dimensional real normed space. Gradients are continuous linear functionals E →L[ℝ] ℝ given by explicit maps Φ' and f'; the dual norm is the operator norm. Φ' is the Fréchet derivative of Φ at each point of D; f' is the derivative of f relative to X at each point of X.
The mirror map definition keeps all three properties of §4.1, including surjectivity of the gradient and divergence at each frontier point of D.
Projections and runs are relations: every admissible argmin choice is covered; no choice function is used. The run is indexed from t=1; index 0 is unused.
Standing and implicit hypotheses: X compact convex; a minimizer x∗∈X exists (the source's standing assumption); ρ>0 and β>0 (so that η=ρ/β and the division by ρt are meaningful); x1∈argminX∩DΦ (unspecified in §4.5, taken as in mirror descent, §4.2).
R is any real with Φ−Φ(x1)≤R2 on X∩D. The source's R2=sup is the case where the supremum is finite; when it is infinite, the source's bound is void.
A run in which the second step started from yt+1, or projected yt+1′ again, would be mirror descent, for which the claimed rate is false; the formal run follows the four equations of the source exactly. The average is over the extrapolated points ys+1, s=1,…,t.
Contributions welcome: proofs of Lemma 4.1 and the three-term bounds, which are reusable for the stochastic mirror descent and saddle-point missions of this series, and the final telescoping and limit argument.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. https://arxiv.org/abs/1405.4980v2
A. Nemirovski, Prox-method with rate of convergence O(1/t) for variational inequalities with Lipschitz continuous monotone operators and smooth convex-concave saddle point problems, SIAM Journal on Optimization 15(1):229–251, 2004. https://doi.org/10.1137/S1052623403425629
A. Beck and M. Teboulle, Mirror descent and nonlinear projected subgradient methods for convex optimization, Operations Research Letters 31(3):167–175, 2003. https://doi.org/10.1016/S0167-6377(02)00231-6
A. Nemirovski and D. Yudin, Problem Complexity and Method Efficiency in Optimization, Wiley, 1983.
Newton's method is the basic second-order method of continuous optimization: at the current point it replaces the objective by its second-order Taylor model and jumps to the stationary point of that model. Its defining property is speed near a nondegenerate minimum, where the error is squared at every step, so that the number of correct digits roughly doubles per iteration. This local behaviour is what makes Newton's method the inner engine of interior point methods, the polynomial-time algorithms for linear, conic and general convex programming (Nesterov and Nemirovski, 1994). In S. Bubeck's monograph Convex Optimization: Algorithms and Complexity (Foundations and Trends in Machine Learning, 2015; arXiv:1405.4980v2), §5.3.2 recalls the traditional local analysis of Newton's method, Theorem 5.3, before turning to the affine-invariant self-concordance analysis used for interior point methods. This mission formalizes that theorem and the four steps of its proof.
Setting
Let Rn carry the Euclidean norm ∥⋅∥, and write ∥A∥ for the operator norm of a linear map A:Rn→Rn, so that ∥Ax∥≤∥A∥∥x∥. Let f:Rn→R be a C2 function, with gradient ∇f(x)∈Rn and Hessian ∇2f(x), a linear map Rn→Rn (the derivative of the gradient map). For a real number c, A⪰cIn means ⟨Av,v⟩≥c∥v∥2 for all v∈Rn.
The Hessian is M-Lipschitz if ∥∇2f(x)−∇2f(y)∥≤M∥x−y∥ for all x,y∈Rn.
Newton's method starts at x0∈Rn and iterates, for k≥0,
xk+1=xk−[∇2f(xk)]−1∇f(xk).
A point x∗ is a local minimum of f if f(x∗)≤f(x) for all x in a neighbourhood of x∗; it has strictly positive Hessian if ∇2f(x∗)⪰μIn for some μ>0.
Formalization targets
Goal: Theorem 5.3 (p. 320)
Assume the Hessian of f is M-Lipschitz, M>0, and x∗ is a local minimum with ∇2f(x∗)⪰μIn, μ>0. If ∥x0−x∗∥≤μ/(2M), then Newton's method from x0 is well defined (every Hessian along the iterates is invertible, so the sequence exists and is unique) and
∥xk+1−x∗∥≤μM∥xk−x∗∥2(k≥0),xk→x∗.
Milestones (p. 321, the steps of the proof)
The integral formula ∫01∇2f(x+sh)hds=∇f(x+h)−∇f(x).
The error representation of one Newton step, xk+1−x∗=[∇2f(xk)]−1∫01[∇2f(xk)−∇2f(x∗+s(xk−x∗))](xk−x∗)ds.
The Lipschitz bound ∫01∥∇2f(xk)−∇2f(x∗+s(xk−x∗))∥ds≤2M∥xk−x∗∥.
The Hessian lower bound ∇2f(xk)⪰(μ−M∥xk−x∗∥)In⪰2μIn when ∥xk−x∗∥≤μ/(2M).
Significance
The theorem gives a quantitative basin of quadratic convergence: an explicit radius μ/(2M), depending only on the curvature at the minimum and the Lipschitz constant of the Hessian, inside which Newton's method needs only O(loglog(1/ε)) iterations to reach accuracy ε. It is the classical statement whose shortcomings (dependence on a choice of norm, constants that change under linear changes of variables) motivate the self-concordance theory of the following subsections, and it is the local convergence result invoked whenever a damped or globalized Newton scheme is shown to enter its quadratic phase.
On the formal side, Mathlib has the calculus this needs (Fréchet derivatives, interval integrals of vector-valued maps, operator norms) but no convergence theorem for multivariate Newton's method for minimization. A formal proof produces reusable pieces: the integral form of the mean value theorem for gradients, the stability of a positive-definite lower bound under Lipschitz perturbations, and an inverse-operator norm bound from a quadratic-form lower bound. The result itself is classical and fully proved in the literature; what is open here is its machine-checked proof in this form.
Difficulty
The individual inequalities are short, but the argument is an induction in which well-definedness and the rate are proved together: the Hessian at xk is invertible only because xk is still in the ball of radius μ/(2M), and xk+1 stays in that ball only because of the rate. A proof that first assumes the sequence exists and then bounds it is circular. The proof also passes between two kinds of control on the Hessian, a lower bound on its quadratic form and an operator-norm bound on its inverse, and the second is only meaningful once invertibility is established. Finally, the integral manipulations need integrability of the maps s↦∇2f(x∗+s(xk−x∗))(xk−x∗), which comes from the continuity of the Hessian.
Formalization scope
Rn is EuclideanSpace ℝ (Fin n). The gradient and Hessian are explicit maps g:Rn→Rn and H:Rn→(Rn→LRn) with ContDiff ℝ 2 f, HasGradientAt f (g x) x and HasFDerivAt g (H x) x at every point; the norm on H(x) is Mathlib's operator norm, as on the page. A⪰cIn is the quadratic-form inequality. A Newton run is a sequence x:N→Rn indexed from 0 satisfying the linear system ∇2f(xk)(xk−xk+1)=∇f(xk); no inverse of a possibly singular operator appears in any hypothesis, and "well defined" is a conclusion: a unique run exists from x0 and every Hessian along it is bijective. The rate and xk→x∗ are asserted for every run. The error representation is stated with both sides multiplied by ∇2f(xk), which is equivalent to the printed form once the Hessian is invertible. Milestones 3 and 4 use only the Lipschitz property and are stated for any Lipschitz map H.
Added hypothesis: M>0 (the radius μ/(2M) divides by M; with M=0, Lean's convention μ/0=0 would collapse the hypothesis to x0=x∗). Convexity of f is not assumed, as on the page; x∗ is a local minimum and ∇f(x∗)=0 is derived, not assumed. Encoding the Newton step with Lean's inverse (which returns 0 on singular maps), or replacing ∇2f(x∗)⪰μIn by mere invertibility, would change the theorem and is ruled out.
A complete development needs the fundamental theorem of calculus for C1 vector-valued maps along segments, Hessian-based quadratic-form estimates, and operator-norm bounds for inverses; all are reusable for the analysis of damped Newton, cubic regularization and interior point methods. Proofs of the milestones independently of the goal are welcome.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980v2, §5.3.2, Theorem 5.3, pp. 320–321.
Yu. Nesterov and A. Nemirovski, Interior-Point Polynomial Algorithms in Convex Programming, SIAM Studies in Applied Mathematics 13, 1994. doi:10.1137/1.9781611970791
Yu. Nesterov, Introductory Lectures on Convex Optimization: A Basic Course, Kluwer, 2004, Theorem 1.2.5. doi:10.1007/978-1-4419-8853-9
Convex Optimization: Algorithms and Complexity XIV: Stochastic Mirror Descent on a β-Smooth Function with Noise σ Has Rate Rσ√(2/t) + βR²/tTextbook
Motivation
Many optimization problems in statistics and machine learning ask to minimize an expected loss f(x)=Eξℓ(x,ξ), or an average f(x)=m1∑i=1mfi(x) over a large data set. Exact gradients of such an f are unavailable or too expensive, but unbiased random estimates are cheap: the gradient of the loss at one sample, or of one randomly chosen summand. The observation that first-order methods still make progress when the gradients are only correct on average goes back to Robbins and Monro (1951) and underlies stochastic gradient descent.
Chapter 6 of S. Bubeck, Convex Optimization: Algorithms and Complexity (2015), studies this setting through stochastic mirror descent (S-MD). Its Section 6.1 shows that in the non-smooth case a noisy oracle costs nothing in rate. Section 6.2 asks what smoothness buys: for a general stochastic oracle it cannot buy acceleration, but Theorem 6.3, whose proof the book takes from Dekel, Gilad-Bachrach, Shamir and Xiao (2012), shows that the rate splits into a noise term of order 1/t and a smoothness term of order 1/t. The book uses it to justify mini-batch SGD. This mission is the fourteenth of a series that formalizes the section capstones of the book.
Setting
Let E be a finite-dimensional real vector space with an arbitrary norm ∥⋅∥. Gradients are linear forms g on E, the value of g at v is written g⊤v, and the dual norm is ∥g∥∗=sup∥v∥≤1g⊤v. Let X⊆E be compact and convex.
A mirror map is a function Φ on an open convex set D with X⊆D and X∩D=∅. It is strictly convex and differentiable on D, its gradient ∇Φ takes every value, and ∥∇Φ(x)∥∗→∞ as x approaches the boundary of D. Its Bregman divergence is DΦ(x,y)=Φ(x)−Φ(y)−∇Φ(y)⊤(x−y). The map is 1-strongly convex on X∩D if DΦ(y,x)≥21∥x−y∥2 there. A function f is β-smooth on X if ∥∇f(x)−∇f(y)∥∗≤β∥x−y∥ for x,y∈X.
A stochastic oracle returns, at a query point x, a random linear form g~(x). When the query point is itself random, the book requires the conditional expectation given the query point, E(g~(x)∣x), to be a subgradient of f at x. In the smooth case it requires E(g~(x)∣x)=∇f(x) together with the variance boundE(∥g~(x)−∇f(x)∥∗2∣x)≤σ2.
S-MD with step γ starts at x1∈argminX∩DΦ and, writing g~s=g~(xs), iterates
xs+1∈x∈X∩Dargminγg~s⊤x+DΦ(x,xs).
Let R2≥supx∈X∩DΦ(x)−Φ(x1), and let x∗ minimize f on X.
Formalization targets
Goal: Theorem 6.3
Let f be convex and β-smooth, and let the oracle have variance at most σ2. Then for every t≥1, S-MD with step 1/(β+1/η) and η=σR2/t satisfies
Ef(t1s=1∑txs+1)−f(x∗)≤Rσt2+tβR2.
Milestones (the proof's four displays)
For points xs,xs+1∈X∩D and η>0, the smoothness step is
Combining the two gives a pathwise bound on f(xs+1) with the cross term (g~s−∇f(xs))⊤(x∗−xs). Taking expectations gives the expected one-step bound
For a convex f with E(∥g~(x)∥∗2∣x)≤B2, S-MD with η=BR2/t satisfies
Ef(t1s=1∑txs)−Xminf≤RB2/t.
This rests on the deterministic regret bound (4.10) of mirror descent along arbitrary vectors gs:
s≤t∑gs⊤(xs−x)≤ηR2+2ρηs≤t∑∥gs∥∗2.
Significance
Theorem 6.3 says exactly how much smoothness helps under noise. As σ→0 it recovers the βR2/t rate of deterministic smooth optimization. For large t the noise term Rσ2/t dominates; the book notes, citing Tsybakov (2003), that smoothness brings no acceleration for a general stochastic oracle. Averaging m independent oracle answers divides the variance by m, so the theorem quantifies the benefit of mini-batches: the noise term shrinks by m while the smoothness term is unchanged. Theorem 6.1 is the matching non-smooth statement and the template for stochastic subgradient methods in any norm.
These are classical, proved results. None of them is known to be formalized in Lean, and the platform has no stochastic mirror descent statement. Its stochastic gradient items cover the Euclidean strongly convex case and the non-convex gradient-norm case. This mission adds a reusable stochastic-oracle layer in an arbitrary norm, with conditional expectations given random query points, on top of the mirror-map layer of Chapter 4.
Difficulty
The deterministic steps are short manipulations of Bregman divergences. The difficulty is in the passage to expectations. The query point xs is random, so unbiasedness enters only through the conditional expectation given xs. Making the cross term vanish requires pulling the σ(xs)-measurable vector x∗−xs out of a conditional expectation of a dual-valued random variable. Every expectation also has to exist. When ∇Φ blows up at the boundary of D, the Bregman terms DΦ(x∗,xs) are not bounded a priori, and their integrability has to be derived from the recursion. A further obstacle is that the minimizer x∗ may lie on the boundary of D, where Φ is not part of the book's data. Treating E informally, or assuming x∗∈D, skips exactly these points.
Formalization scope
Spaces and gradients.E is a finite-dimensional real normed space. Gradients are explicit maps Φ' f' : E → (E →L[ℝ] ℝ), g⊤v is g v, and ∥⋅∥∗ is the operator norm. β-smoothness is stated with derivatives relative to X. Φ is a total function, constrained only by the mirror-map axioms on D.
Runs and oracle. S-MD is a run predicate. For every outcome, x1 minimizes Φ on X∩D, and xs+1 is some minimizer of the step objective. The oracle is a predicate on the random sequences (xs,g~s): each xs is measurable, and the conditional expectations are taken given σ(xs). Every conditioned quantity is integrable.
Conclusions. Every bound on an expectation also asserts integrability. Without it, the Lean integral of a non-integrable function is 0 and the bound could hold trivially.
Standing assumptions. The book's R2=sup(Φ−Φ(x1)) is replaced by any upper bound R2. The minimizer x∗∈X exists (p. 242). X is compact and convex (Chapter 4), and convex functions are closed (p. 236).
Positivity side conditions.R,σ,B>0 and t≥1 make the step sizes and bounds defined, and β≥0.
A variance hypothesis stated only at deterministic points would not control the random iterates, and is not used. Run predicates that let xs+1 be an arbitrary point of X∩D would make the theorems false, and are not used either.
A complete development needs: first-order optimality over a convex set, the three-point identity of Bregman divergences, the descent lemma in an arbitrary norm, and continuity of the gradient of a differentiable convex function. On the probability side it needs pull-out and conditional Jensen properties for dual-valued conditional expectations. The probability layer is reusable for every stochastic first-order method in the book, including SVRG and random coordinate descent. Proofs of the milestones are welcome, and so are general lemmas about conditional expectations of continuous-linear-map-valued random variables.
Selected references
S. Bubeck, Convex Optimization: Algorithms and Complexity, Foundations and Trends in Machine Learning 8(3–4):231–358, 2015. arXiv:1405.4980v2, https://arxiv.org/abs/1405.4980 (Chapter 6, pp. 329–333; Chapter 4, pp. 297–307).
O. Dekel, R. Gilad-Bachrach, O. Shamir, L. Xiao, Optimal distributed online prediction using mini-batches, Journal of Machine Learning Research 13:165–202, 2012. https://jmlr.org/papers/v13/dekel12a.html
A. Beck, M. Teboulle, Mirror descent and nonlinear projected subgradient methods for convex optimization, Operations Research Letters 31(3):167–175, 2003. https://doi.org/10.1016/S0167-6377(02)00231-6
A. Nemirovski, A. Juditsky, G. Lan, A. Shapiro, Robust stochastic approximation approach to stochastic programming, SIAM Journal on Optimization 19(4):1574–1609, 2009. https://doi.org/10.1137/070704277