What OpenAI's Astra Threw Away to Solve 10 Hard Problems · Issue #191

Opening

On August 1st, OpenAI announced that an internal version of its next model, Astra, had solved 10 hard problems in mathematics and theoretical computer science. Most domestic headlines converged on a single number: ₩2,890,000 (~$2,080).

But there wasn’t just one document posted that day. There’s a 249-page paper laying out the results, a machine-verified formal proof repository, and one more document — 62 pages long. Its title: How the Ideas Came Together.

Reader, open this document and something feels off. There’s barely any talk of right answers. Instead, it’s page after page of “why this approach didn’t work.”

Let me give you the conclusion up front. What’s genuinely new about this announcement isn’t that AI found the answers. It’s that OpenAI documented and published, separately, every path it erased on the way there.

First, What Are These 10 Problems

You don’t need to understand all the details. Just get a feel for what kind of problems these are.

#	Problem	In plain terms
1	High-dimensional sphere packing	How densely can you pack spheres together at most?
2	Binary and spherical codes	How many error-tolerant codes can you construct at most?
3	Non-sofic groups	Are there infinite symmetry structures that can’t be approximated by finite shuffling?
4	Connes rigidity conjecture	Can you reconstruct a structure just by looking at its shadow?
5	Arithmetic circuit complexity	What’s the minimum number of multiplications a given computation requires?
6	Quantum parallel repetition	Does the winning probability drop sharply when you repeat the same game multiple times?
7	Closest vector problem	How hard is it to find the nearest point in a lattice?
8	Ehrhart volume conjecture	What’s the maximum volume a shape meeting certain conditions can have?
9	Multicolor Ramsey numbers	No matter how many colors you use, do you always end up with a same-color triangle?
10	Extremal graph theory	How many lines can you draw at most while avoiding a specific shape?

Problems 3 and 4 have been open since 1999 and the 1980s, respectively. Problems 9 and 10 correspond to numbers 183, 146, and 180 on Erdős’s list of open problems. The answers also come in different shapes — some are new proofs, others are counterexamples that demolish conjectures long believed to be true.

cdn.openai.com

One small fact worth flagging: OpenAI counts the results as 10, but the walkthrough document has 12 chapters. Problem 5 splits into a circuit version and a formula version; problem 10 splits into two separate extremal graph theory results. The formal proof repository also bundles 12 endpoints into 10 results. It’s not a big deal, but it’s worth knowing that “10” isn’t a natural unit — it’s an edited one.

What the Walkthrough Actually Shows

Now for the main point. As I read through the 62-page document and counted, 10 of the 12 chapters open with a failed approach. Even the chapter titles say so: “Why the First Recurrence Was Wrong,” “A Long, Useful, Failed Path,” “Why the Obvious Reduction Couldn’t Work.”

The shapes of failure differ. Let me break them into four types.

Type 1: The Plausible Analogy That Was Wrong

Chapter 2, the error-correcting code problem.

The model borrowed a formula from a similarly structured problem and applied it. The shape looked right. But then it plugged the formula into a tiny test case — a length-8 code.

The formula’s upper bound came out to 508 divided by 7 — about 72.6. But 128 such codes actually exist. In other words, the formula was claiming “at most 72” for a set of 128.

That’s not a rounding error — it’s a death sentence. An upper bound smaller than the actual value means something in the calculation is structurally wrong. The document sums it up this way: this wasn’t a harmless normalization issue, it flagged a structural error.

Recalculating with the corrected formula gave about 261.8 — larger than 128. Now it makes sense.

What’s impressive here isn’t that it fixed the formula. It’s that the model went looking for the smallest possible case that could kill its own idea, and tested it.

Type 2: The Shortcut That Destroyed the Destination

Chapter 10, the Ramsey number problem. The goal is to color things such that no same-color triangle emerges.

The model came up with a shortcut. Using permutations, k colors could generate k-factorial points. With 10 colors, that’s 3.6 million. Extremely efficient.

But checking it revealed that under this scheme, three permutations could move the same position to three different places. And those three, together, formed exactly a same-color triangle. The structure was generating precisely what it was meant to prevent.

Something similar happens in Chapter 5. To prove a computational lower bound, the model added a correction term to each element — but the number of multiplications that correction required turned out to equal the exact number of multiplications the proof was trying to establish. The structure paid out exactly what it was trying to win, leaving nothing behind.

Type 3: Not a Failure, But Proof of Failure

Chapter 1, sphere packing. This is the most interesting one.

The model approached the goal using a standard inequality. But it stalled around half of the target value. The natural next thought here is usually “maybe I just need to tighten the constant.”

The model did something else. It produced a counterexample showing that this direction could never reach the target value. The document’s diagnosis: this isn’t a matter of an under-optimized constant. A tool that only measures overall magnitude forgets where the problem actually lives.

It wasn’t stuck — it proved that it was stuck. So instead of tightening the constant, it swapped out the tool itself, and that’s when progress actually began.

This distinction matters enormously in practice, too. “Not there yet” and “this direction won’t work” lead to completely different next steps.

Type 4: Finished, Then Discarded

Chapter 8, the closest vector problem, which connects to lattice-based cryptography. This is where the headline comes from.

The model approached this using signed histograms over a prime field, and it went all the way through. The document explicitly states this path provides a complete construction — meaning it was a proof that worked.

But that’s not what made it into the final version. What’s there instead is a rewrite in characteristic 2 — a world where addition reduces to just odd and even. The signed histogram became an odd/even table; complex cancellations became simple parity checks. It reaches the same conclusion with far fewer moving parts.

Chapter 9 devotes an entire section to a failure. It’s titled “A Long, Useful, Failed Path.” That path found exactly the right shape for the answer. But it couldn’t explain the factorial attached to that shape’s volume — it got the answer right without being able to say why. The document classifies this as a failure, yet notes it was useful anyway: it revealed why the factorial was needed in the first place.

There’s an even better moment in the same chapter. Midway through, the model writes that the temptation to treat two functions as identical here is very strong. It then immediately produces a counterexample to kill that temptation, adding that giving in would have built the proof on a false identification.

Chapter 12 is upfront from the start. The section’s opening line reads: “We initially set out to find a proof.” The chapter ends with a counterexample — meaning it began without even knowing whether the claim was true or false.

So How Far Do These Results Actually Reach

This is where my occupational habit kicks in. Any claim of an achievement needs its scope checked first.

A good deal of domestic coverage tied the closest vector problem to post-quantum cryptography. The direction is right. But look at the dimension this result actually covers: input size to the 401st power. That number won’t mean much on its own, so here’s a sense of scale — even with an input of just 10, you get a 1 followed by 401 zeros. The number of atoms in the observable universe is roughly a 1 followed by 80 zeros. The walkthrough doesn’t hide this; it says so directly. This claim is about polynomial-time computability, not practical efficiency. It’s not an attack on the cryptography we use today.

newsletter thumbnail image The Ramsey number result in problem 9 is similar. For the new lower bound to matter, you need at least 342 colors. Below that, the previously known trivial lower bound is stronger. The circuit lower bound in problem 5 only holds once matrix size exceeds 65,000.

Formal verification tells a similar story. OpenAI states that it formalized every result in Lean¹, with no incomplete goals and only standard axioms used. That’s strong evidence. But the review status marked in the repository is “agent-reviewed.” And what a machine verifies is the logical derivation — not whether the formalized statement matches the original problem. That comparison is still a human job, and none of this has gone through peer review yet.

British mathematician Thomas Bloom called the announcement “incredible news.” Terence Tao, meanwhile, has been raising a different worry for some time: that AI-generated proofs are piling up faster than humans can understand and absorb them — a state he calls proof indigestion.

The key thing here is that these two reactions aren’t contradictory. A result being genuine and academia digesting it are two separate matters. This is exactly the point the Leiden Declaration², endorsed by the International Mathematical Union on June 2nd, calls for: verifiability, source attribution, and an honest record of who did what.

With that in mind, one line in OpenAI’s announcement deserves attention: attaching human authorship to a proof that was entirely AI-generated distorts both the system’s contribution and human intellectual work. It’s unusual for a company to disclaim its own share of authorship.

Oswarld’s Lens

I think the most valuable output from this announcement is the 62-page book of wrong answers.

There’s a scene I run into every single time I work on a GTM strategy project. The final deliverable is a one-page recommendation. But more than 70 percent of the actual work goes into killing candidates that never make it onto that page — why this channel doesn’t work, where this pricing structure breaks down, why hitting this segment first blocks the next step.

The problem is that 70 percent never makes it into the document. Options that were considered and rejected either get pushed into an appendix or dropped entirely. Nobody asks about them in the meeting. So here’s what happens: six months later, a different team brings back the exact same idea as if it were new. The organization ends up repeatedly buying the same wrong answer. I’ve watched this play out at company after company, and I keep arriving at the same conclusion: an organization’s real asset isn’t the option it adopted, but the reasons behind the options it discarded.

What makes this announcement interesting is that it flips that asymmetry. If you only show the success, you can’t answer the question “didn’t you just get lucky?” But if you also present which paths you erased and why, readers can follow the trajectory of the judgment itself. That becomes the basis for trust.

One more thing. I’ve long been uneasy about the market for content that only collects success stories — that kind of content always works backward from the outcome to build a narrative. This document does the opposite. Because the erased paths remain as a list, readers get room to verify things for themselves. I think this format should become the standard for AI-generated performance claims across the board.

Let me be clear about one thing, though. This document is not a raw record of the actual thinking process. It’s a narrative reconstructed by a separate AI model that read the original logs alongside the final paper. Any after-the-fact account always carries a bias toward looking smoother than reality was. So this is closer to a well-written memoir than a lab notebook. Still, a memoir beats having no record at all.

Closing

Let me sum this up in three lines.

Separate from the results paper, a 62-page document cataloging only the erased paths came out alongside it. 10 of its 12 chapters open with a failed approach.
Failure comes in four shapes: a wrong analogy, a shortcut that destroyed its own destination, proof of being stuck, and a completed proof thrown away.
The practical scope is narrow. A leap in capability and a leap in application are different axes.

Here’s one thing I’d suggest trying after reading this. If you made a decision this week, jot down two lines next to the option you chose: the option you discarded, and why. Six months from now, those two lines will save you an hour-long meeting.

Does your organization actually document “we considered this, and here’s why it doesn’t work”? If you do, tell me the format in the comments. If you don’t, tell me where it breaks down. If enough examples come in, I’ll put together a practical format for keeping elimination records in a future issue.

💬 If you have a way of documenting discarded options, share it in the comments

📨 If you have a colleague reviewing the same conclusion twice, forward this piece to them

References & Further Reading

Primary sources

OpenAI, “Ten advances in mathematics and theoretical computer science,” August 1, 2026. Link ··· The original post listing all 10 results, with OpenAI’s stance on authorship. Even just reading the final paragraph, “Responsibility to the Mathematics Community,” is worth your time.
OpenAI, How the Ideas Came Together, 62 pages, August 1, 2026. Link ··· The core evidence behind today’s issue. Skip the equations and just skim the first two section titles of each chapter — that alone reveals the character of this document.
OpenAI, Ten Advances in Mathematics and Theoretical Computer Science, 249 pages. Link ··· The results paper itself. Check the dimension calculation at the end of Chapter 8 — it makes the scope discussion far more concrete.
OpenAI, “ten-proofs” formal proof repository, GitHub. Link ··· The 10 results split into 12 formal endpoints. Worth checking the review status labels yourself.

Background

Leiden Declaration on Artificial Intelligence and Mathematics, June 2, 2026. Link ··· The declaration endorsed by the International Mathematical Union. It gathered over 1,000 signatures within 24 hours of release. Recommended reading before this announcement.
Henry Cohn and Noam Elkies, “New upper bounds on sphere packings. I,” Annals of Mathematics 157 (2003), 689–714. Link ··· The 2003 paper that set the threshold problem 1 is said to have reached. Reading its first two sections places this result in context.

📝 Glossary

The author, Kwangseob Ahn, is a professor of business administration at Sejong University and lead consultant at OBF (Oswarld Boutique Consulting Firm). He teaches statistics and data analysis, including business data management and business analytics, while leading GTM and AI strategy consulting in the field, designing the seam between technology and business. He has published academic research on a memory architecture for AI dialogue systems (HEMA) and runs Daily Arxiv, a daily curation of global AI papers. He holds a master's from Korea University's Graduate School of Technology Management and a KMBA. He is the author of Homo Brainless: The People Who Outsource Their Thinking.

Footnotes

Lean: A language for writing mathematical proofs in a form a computer can check line by line. Instead of a person reading it and deciding it looks correct, a machine automatically catches logical gaps. That said, what it checks is the logical derivation — whether the formalized statement matches the original problem is still something a human has to verify. ↩
Leiden Declaration: An international statement on the relationship between AI and mathematics, released on June 2, 2026. It grew out of a workshop held in Leiden, the Netherlands in September 2025, and was endorsed by the International Mathematical Union. Rather than banning AI use, it calls for verifiability, source attribution, and research autonomy. ↩