OpenAI's Unreleased Model Cracked Ten Open Problems. In One Week.

TL;DR

On August 1, OpenAI published a 249-page manuscript claiming ten new results in mathematics and theoretical computer science, produced by an internal version of Astra, its unreleased next model family. Every result ships with a machine-checkable Lean 4 proof in the openai/ten-proofs repo: 548,207 lines of Lean across ten files, zero sorry placeholders, and no axioms beyond the three that ship with Lean itself. The repo's own manifest records the part the announcement does not lead with: one week of wall time, and a review status of agent-reviewed.

Three artifacts, not one press release

This is not a benchmark score. OpenAI shipped three things at once, and the third is the one that changes the argument.

• A 249-page manuscript whose PDF metadata lists the subject as "A collection of research papers by an internal model at OpenAI."
• A 62-page set of reasoning walkthroughs reconstructing how each proof came together, including the dead ends. Its own abstract says these notes "were written by an AI model that read the original chains of thought," so the narrator of the discovery story is also a model.
• The Lean formalizations, Apache-2.0, built against mathlib on Lean 4.32.0.

The problems span high-dimensional geometry, coding theory, group theory, quantum complexity, lattice cryptography, and extremal combinatorics. OpenAI says none of them had seen progress on the main result for at least a decade, and most for far longer.

The ten

• Sphere packing. The exact exponential rate of the Cohn-Elkies linear program is determined, which improves the classical general packing bound in high dimensions.
• Binary and spherical codes. A strict improvement over the classical MRRW bound, by exponential factors, at every minimum distance.
• Non-sofic groups. An explicit finitely presented non-sofic group, settling whether every countable group admits finite permutation approximations.
• Connes's rigidity conjecture. Infinitely many pairwise nonisomorphic property-(T) groups with the same group von Neumann algebra, which disproves it.
• Arithmetic circuit complexity. For the permanent, division-free circuits need Ω(n² log log n) gates and formulas need Ω(n⁴/log n) leaves.
• Quantum parallel repetition. Exponential parallel repetition for every finite two-player entangled game.
• Closest vector problem. A direct 3SAT reduction giving n^1/400-factor hardness for Euclidean CVP.
• Ehrhart's volume conjecture. The sharp bound (n+1)ⁿ/n! in every dimension.
• Multicolor Ramsey numbers. A superexponential lower bound establishing R_k(3) = k^Θ(k), resolving Erdős problem 183.
• Extremal graph theory. Counterexamples to the Erdős-Simonovits compactness conjecture and a degeneracy conjecture, resolving Erdős problems 146 and 180.

Why the Lean files are the story

Every previous "AI solved an open problem" claim died the same death: a plausible-looking argument that nobody could check without burning a month of a senior mathematician's life. Lean removes that step. The compiler either accepts the proof or it does not, and it does not care who wrote it.

Two numbers in the repo's formalization.yaml carry all the weight. sorry_count: 0 means no step is stubbed out with Lean's escape hatch. And the recorded axiom set is exactly propext, Classical.choice, and Quot.sound, the three that come standard with Lean's own foundations.

That second one matters more than it looks. In Lean you can always make a theorem "true" by quietly declaring a new axiom that assumes it, the way you can balance any budget by adding a line item called "money we found." Publishing the axiom list is the receipt that no such line item exists. Anyone with elan and a few hours of CPU can run lake build All and confirm it independently, and the repo even ships configs for Comparator, a third-party kernel checker, so you do not have to trust Lean's own elaborator either.

The confession is in the YAML

The most interesting file in the repo is not a proof. It is formalization.yaml, and its automation block reads: method agent, model "Astra (OpenAI)", framework Codex, wall time "1 week." Then, three lines later: review: status: "agent-reviewed".

So the proofs were found by a model, formalized by a model driving a coding agent, and reviewed by a model. The Lean kernel is the only party in that chain with no opinions. That is either the most rigorous thing about the release or the most unsettling, depending on how much you trust a compiler over a referee, and the honest answer is that for a formal proof, the compiler is the one you should trust.

What the kernel cannot tell you is whether the Lean theorem statement means what the English abstract says it means. If exists_finitelyPresented_nonsofic_group is stated over a subtly wrong definition of soficity, Lean will happily certify a true theorem about the wrong object. Checking that the formal statement matches the informal claim is still human work, and it is the review that has not happened yet.

OpenAI does credit humans in the right places. The manuscript's acknowledgments thank working mathematicians by name for comments on the non-sofic and Connes chapters, and the manifest credits the community Sphere-Packing-Lean project as prior art. OpenAI's framing is that its researchers helped prepare and formalize, while the mathematical arguments came from the model.

What it cost, and what it did not solve

OpenAI says the tokens used to produce all ten solutions would have run roughly $2,000 at its Sol API rates. Treat that as a floor, not a bill: it is the retail price of the winning transcripts, not the compute spent on everything that failed.

Noam Brown, one of the researchers behind the test-time reasoning work, was blunt about the misses on X: "we did try other major problems without success. Sadly no Millennium Prize problems (yet). But also, we didn't spend a lot on each problem. It's possible to push test-time compute much further." A frontier lab openly logging its failure rate is rare enough to note.

What builders should take from this

Astra is not available. There is no release date, no pricing, no API. What you can use today is the pattern, and the pattern is reusable outside mathematics: run a strong model against a hard problem, then force the output through a verifier the model does not control, and publish the verifier's artifact instead of the model's prose.

Lean happens to be the cleanest example because mathematics has a total oracle. Most domains do not. But the same shape works with a type checker, a property-based test suite, a proof-carrying build, or a fuzzed differential harness. If your agent pipeline currently ends with a model summarizing its own work, you are shipping the 249-page PDF and skipping the 548,207 lines.

The skeptical read is still available and still reasonable. These results are not peer reviewed, the community consensus process has not started, and the field's response to the June Leiden Declaration suggests mathematicians are in no hurry to let a lab's blog post substitute for it. Thomas Bloom, who runs erdosproblems.com, called the results "big news" and said that in terms of constructions this is big, which is roughly the right temperature: significant, verifiable in principle, unratified in practice.

Key Takeaways

• OpenAI published ten new results in math and theoretical computer science on August 1, produced by an internal version of its unreleased Astra model family, in a 249-page manuscript.
• All ten ship as Lean 4 formalizations: 548,207 lines, sorry_count: 0, and only the three axioms Lean ships with, so anyone can recheck them without trusting OpenAI.
• The repo manifest records one week of wall time, Codex as the agent framework, and a review status of agent-reviewed. No human peer review has happened yet.
• Lean certifies that the formal statement is proved, not that the formal statement matches the English claim. That gap is still human work.
• OpenAI puts the token cost of all ten at roughly $2,000 at Sol rates, and Noam Brown confirmed other major problems were attempted and failed, with no Millennium Prize results.
• The transferable lesson is architectural: end your agent pipeline with a verifier the agent cannot influence, and publish the verifier's output.

Sources: OpenAI, Ten advances in mathematics and theoretical computer science, the 249-page manuscript (PDF), reasoning walkthroughs (PDF), openai/ten-proofs on GitHub, Noam Brown on X, The Next Web, The Decoder.