OpenAI's Astra Just Solved 10 Open Math Problems — With Proofs You Can Check

On 1 August 2026, OpenAI said an internal build of its next model — Astra — had solved ten open problems in mathematics and theoretical computer science. That claim alone would be forgettable; the field is drowning in "AI does math" press releases. What makes this one different is the receipt: OpenAI didn't just assert the answers. It published machine-checkable Lean proof files on GitHub and a 249-page manuscript, so anyone — no trust in OpenAI required — can run a proof checker and see for themselves. The compute bill to find all ten: roughly $2,000.

10open problems closed

1999year the headline one opened

~$2,000compute to find all ten

249page manuscript, proofs in Lean

The headline result: a non-sofic group

Strip away the marketing and one result stands above the rest: the first explicit construction of a non-sofic group.

If that means nothing to you, here's the short version. Soficity is a property of groups introduced (in spirit) by Mikhail Gromov around 1999 — roughly, whether a group can be approximated by finite permutations. Ever since, one question sat open: does a non-sofic group even exist? Nobody could construct one, and nobody could prove they were impossible. For ~27 years it was one of those clean, load-bearing "we simply don't know" questions in group theory. Astra produced an explicit construction — and, crucially, a proof a computer can verify.

That's the part that should make you sit up. Not "an AI did a hard problem," but "an AI closed a question that stood for a generation, and handed over a proof that doesn't require you to believe it."

Why the Lean proofs matter more than the result

Here's the engineering lesson, and it generalizes far past pure math.

Most AI-does-science claims fail on verifiability. A model outputs a plausible argument; a human has to read it, and plausible-looking mathematical prose is exactly where LLMs have historically hidden their mistakes. The gap between "sounds right" and "is right" is where the entire replication crisis lives.

Lean collapses that gap. A Lean proof is a program: it either type-checks or it doesn't. By emitting proofs in a formal proof assistant, OpenAI moved the claim from "trust our benchmark" to "here is an artifact you can independently execute." This is the same principle that makes a passing test suite more convincing than a paragraph of "it works" — truth you can run beats truth you have to read.

Old way	Astra's way
Model asserts an answer	Model emits a Lean proof term
Human referee reads prose	Proof checker type-checks it
Trust the lab's eval	Reproduce it yourself for ~$0
"Sounds correct"	Mechanically correct or rejected

The reception (and the caution)

The response from working mathematicians has been measured but real. Fields Medalist Timothy Gowers said he'd recommend one of the proofs for a top journal without hesitation. Thomas Bloom, who curates the well-known Erdős problems catalogue, called the constructions a big deal. That's meaningfully different from the usual "impressive demo, but…" — these are people whose job is to not be fooled.

But be precise about the caveats, because the hype will not be:

This is a first-party announcement. The proofs are public and checkable; the narrative around them (how autonomous the model was, how much human scaffolding helped) is OpenAI's account. The math is verifiable; the process story is not, yet.
"Open problem" is doing a lot of work. Ten open problems is genuinely impressive, but the population of open problems ranges from "quietly hard" to "century-defining." Non-sofic groups is a real prize; not all ten are that weight.
Astra is unreleased. This was an internal build. Under the new US Commerce Department review gates for frontier models, don't expect to pip install it soon.

What it means if you build software (not proofs)

You will probably never construct a non-sofic group. So why care?

Because the transferable idea is formal verification as the interface between a capable-but-unreliable generator and a world that needs to trust it. The winning pattern here wasn't "make the model smarter until we believe it." It was "make the model emit something a dumb, deterministic checker can validate." That's a design pattern, not a math result:

Generating code? The equivalent of Lean is a strong type system, a property-based test, a fuzzer — an oracle the model's output must survive.
Generating infra changes? The oracle is a dry-run plan, a policy check, a staging environment that either passes or doesn't.
Generating claims about your data? The oracle is a query that reproduces the number, not a paragraph describing it.

The models are getting good enough that the bottleneck is no longer generation — it's trust. Astra's real contribution is a loud demonstration that the answer to trust isn't faith. It's a checker.

My take

The "AI solved unsolved math" headline is the least interesting thing here. The interesting thing is the shape of the win: an unreliable genius paired with an incorruptible verifier, producing an artifact you can check for the price of a coffee. That's the template for putting frontier models anywhere the cost of being wrong is high. We spent two years asking models to be trustworthy. This says: stop asking. Make them checkable instead.

Sources

Facts reflect reporting as of 11 August 2026 and OpenAI's public account; independent digestion of the proofs is ongoing. Spot a corrected detail? Tell me and I'll update.