⏱️ Lectura: 10 min
GPT-5.6 just closed a 30-year gap in the complexity theory of convex optimization, according to a thread posted on July 15, 2026 on r/math.
📑 En este artículo
This matters for two reasons: the gap had resisted specialists in the field for three decades, and the thread’s author isn’t asking for blind faith. He published the Lean repository so anyone can compile it and confirm, line by line, that there’s no hidden sorry.
TL;DR
- A thread on r/math (July 15, 2026) reports that GPT-5.6 closed a gap that had been open for 30 years in the complexity theory of convex optimization.
- The author applied a variant of the prompt OpenAI used weeks earlier for its proof of the CDC problem (Complexity of Descent Conjecture).
- The proof was formalized in Lean 4 using the Mathlib library and compiles without using
sorry, the marker for unproven steps. - The result extends the optimal convergence bound for first-order methods to the nonsmooth convex case with bounded subgradients.
- The milestone builds on the lineage of Nesterov (1983) and the Optimized Gradient Method by Kim and Fessler (2014), which closed the constant gap in the smooth case.
- The r/math community is debating whether the result is genuinely new or a reformulation of a lemma already known in the Russian optimization literature from the 1990s.
- The project’s Lean code is publicly available so anyone can compile and verify it on any machine.
What happened
The user who started the thread describes a three-step process. First, he asked GPT-5.6 to break the open problem down into small, verifiable lemmas, following the same prompt structure OpenAI used for its announcement of the CDC problem proof weeks earlier. Second, he converted each lemma into a formal statement in Lean 4 before attempting the informal argument. Third, he iterated only on the lemma that failed to compile, instead of rewriting the entire proof each time.
The result, according to the thread, is an extension of the optimal convergence bound for first-order optimization methods to the nonsmooth convex case with bounded subgradients: exactly the zone where the problem had remained unresolved for 30 years. The complete proof, with all its Mathlib dependencies, compiles with lake build without warnings and without the sorryAx axiom, the signal that Lean has accepted an unproven step.
Context and history: 30 years of convex optimization
Convex optimization is the ground where much of machine learning model training lives: minimizing a convex (or reasonably convex) loss function is, at its core, what an optimizer like SGD or Adam does at every step. The underlying question that has chased this field for decades is easy to state and hard to answer: what is the best possible convergence rate for a method that can only query the gradient or subgradient of the function, without second-order information?
In 1983, Yurii Nesterov published his accelerated gradient method, achieving a convergence rate of O(1/k²) in the smooth case, well above the O(1/k) of classical gradient descent. Nemirovski and Yudin had proven a lower bound that same year matching the order of magnitude, but not the exact constant. That constant gap remained open for 31 years, until Donghwan Kim and Jeffrey Fessler published the Optimized Gradient Method (OGM) in 2014, closing the exact gap for the smooth case.
What remained unresolved was extending that result to the nonsmooth case, where the function doesn’t have a gradient at every point and you have to work with bounded subgradients: the typical scenario for loss functions with L1 regularization, SVMs, or theoretical analysis of networks with nondifferentiable activations like ReLU. That, according to the r/math thread, is the 30-year gap the GPT-5.6-assisted proof claims to have closed.
Technical details and performance
The core of the argument is a modified Lyapunov function that couples the momentum term of the accelerated method with an upper bound on the subgradient norm at each step. It’s the same family of technique Nesterov used in his original proof, but with an additional correction term that absorbs the subgradient’s discontinuity at nondifferentiable points.
A simplified fragment of the central statement, as formalized in Lean 4 with Mathlib, looks like this:
import Mathlib.Analysis.Convex.Function
import Mathlib.Analysis.InnerProductSpace.Basic
theorem subgradiente_acotado_tasa_optima
{E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
(f : E → ℝ) (hf : ConvexOn ℝ Set.univ f)
(G : ℝ) (hG : ∀ x g, g ∈ SubderivAt f x → ‖g‖ ≤ G)
(x_star : E) (k : ℕ) (hk : k ≥ 1) :
f (x k) - f x_star ≤ (G * ‖x 0 - x_star‖) / Real.sqrt k := by
sorry -- the full proof has 2,400 lines in the repositoryThat sorry in the example is only to illustrate the statement in this article: in the actual repository, published by the thread’s author, the complete theorem has no sorry at all, and it can be confirmed by running a single command.
#print axioms subgradiente_acotado_tasa_optima
-- expected output: 'subgradiente_acotado_tasa_optima' depends on axioms: [propext, Classical.choice, Quot.sound]Those three axioms (propext, Classical.choice, Quot.sound) are the standard Lean and Mathlib axioms that appear in practically any nontrivial proof in the library. If sorryAx appeared in the list, it would mean there’s at least one unproven step somewhere in the dependency chain.
| Method | Year | Convergence rate | Gap status |
|---|---|---|---|
| Classical gradient descent | 1847 (Cauchy) | O(1/k) | Suboptimal, historical reference |
| Nesterov’s accelerated method | 1983 | O(1/k²), smooth case | Optimal in order, constant not closed |
| Optimized Gradient Method (OGM) | 2014 | O(1/k²), optimal constant proven | Closes the smooth case, leaves the nonsmooth case open |
| GPT-5.6-assisted proof | 2026 | O(1/√k), optimal constant in the nonsmooth case with bounded subgradient | Formalized and verified in Lean with Mathlib |
How to verify it
To verify the proof on your own machine, you need elan, the Lean version installer, and to clone the project’s repository. The installation commands are the same ones used by any Mathlib-based project:
# Linux and macOS
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh
elan toolchain install leanprover/lean4:v4.11.0
# Windows (PowerShell)
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/leanprover/elan/master/elan-init.ps1" -UseBasicParsing | Invoke-ExpressionWith elan installed, the project is built with lake, Lean’s build manager:
git clone https://github.com/leanprover-community/mathlib4.git
cd mi-proyecto-cdc
lake exe cache get
lake buildIf lake build finishes without errors, the proof is valid under Lean’s standard axioms. To confirm that no step was left unproven, run #print axioms on the main theorem as shown above.
Impact and analysis
What makes this case interesting isn’t that a large model produced a plausible argument: that already happens all the time on r/math and usually ends up refuted in the comments. It’s that the argument survived the most hostile step possible, translation into a language with no room for rhetorical ambiguity. Lean doesn’t accept “it can be shown that” or “it’s easy to see that”: it demands the complete logical step or rejects the compilation.
flowchart TD
A["Open problem: 30 years without a proof"] --> B["CDC-style prompt to GPT-5.6"]
B --> C["Proof sketch in natural language"]
C --> D["Formalization in Lean 4"]
D --> E{"Mathlib compiles without sorryAx"}
E -->|Yes| F["Proof verified"]
E -->|No| C⚠️ Heads up: Lean accepting the proof confirms internal consistency given the formal definition used, not that this definition exactly captures the informal conjecture the community had been discussing for 30 years. The gap between the prose statement and the formal statement is, in itself, a classic source of errors in the formal verification of mathematics.
That nuance is exactly what the r/math thread is debating: several commenters point out that the key lemma could be a reformulation of a result already known in the Russian optimization literature from the 1990s, published in journals rarely translated or indexed in Western databases. If that’s confirmed, GPT-5.6’s merit wouldn’t be discovering a new theorem, but finding and reconstructing an argument lost in the literature, and formalizing it in a language no one had used for that before.
💡 Tip: if you want to audit the real merit of an AI-assisted proof, don’t just read the summary: clone the repository, run lake build, and check the commit history to see how many iterations each lemma took to compile. A lemma that compiled on the first try is more suspicious than one that took twenty.
What’s next
The repository is open for community review, and in the coming weeks a convex optimization specialist, probably someone who actually reads the Russian literature from the 1990s, is expected to confirm or dismiss the suspicion of redundancy. Meanwhile, the work pattern (a prompt that breaks the problem into lemmas, immediate formalization in Lean, iterating only on the lemma that fails) is being replicated in other r/math threads to tackle different open problems, which matters more than this specific result: it’s a reproducible workflow using tools anyone can install today.
📖 Summary on Telegram: View summary
Try it yourself: install elan, clone the thread’s repository, and run lake build to see with your own eyes whether the proof compiles without sorryAx.
Frequently Asked Questions
What is convex optimization?
It’s the branch of applied mathematics that studies how to efficiently minimize convex functions (functions whose graph never falls below the straight line connecting any two of its points). It’s the theoretical foundation behind nearly every optimizer used to train machine learning models.
What does the 30-year gap mean in this case?
It refers to the gap between what Nesterov proved in 1983 for the smooth case and what remained to be proven for the nonsmooth convex case with bounded subgradients, a problem open since the 1990s according to the r/math thread.
What is Lean, and why does a mathematical proof go through it?
Lean is a proof assistant: a language and compiler that verify, step by step, that every logical inference in a mathematical proof is valid according to a fixed set of axioms. If a proof compiles in Lean, it can’t have hidden reasoning errors.
What is Mathlib?
It’s Lean 4’s community-driven math library: thousands of already-formalized definitions and theorems (analysis, algebra, measure theory, among others) that any new proof builds on instead of reconstructing everything from scratch.
Is a proof verified in Lean necessarily correct?
It’s logically consistent with respect to its formal statement. But if that statement doesn’t accurately capture the original informal problem, verification doesn’t fix that mismatch: that’s why the community keeps checking whether the formalization actually corresponds to the 30-year conjecture.
Can I verify this proof without being a professional mathematician?
Yes. With elan installed and the repository cloned, running lake build and #print axioms doesn’t require understanding every lemma, just confirming that Lean accepts the entire chain without sorryAx.
References
- Original thread on r/math: report of the proof and link to the Lean repository.
- Lean Prover: official documentation for the proof assistant used to formalize the result.
- Mathlib4 on GitHub: the community math library on which the formalization was built.
- Convex optimization (Wikipedia): general context on the field and its classical methods.
📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
Imagen destacada: Foto de Egor Komarov en Unsplash
0 Comments