OpenAI Astra Cracks 10 Unsolved Math Problems — Total Cost: $2,000

The Short Answer

OpenAI's Astra model represents a leap from AI as a research assistant that retrieves and synthesizes existing knowledge to an independent research collaborator that produces original, verifiable discoveries. Here's what you need to know:

It solved 10 genuinely hard, long-standing problems. These are not toy examples or benchmark exercises. They include: the first improvement to the Cohn-Elkies sphere packing bound since 1978; the first explicit construction of a non-sofic group (settling a problem open since ~2000); a disproof of the Connes rigidity conjecture; new exponential bounds in coding theory; lower bounds in arithmetic circuit complexity; an exponential parallel repetition theorem for quantum games; polynomial-factor hardness for the Closest Vector Problem (relevant to post-quantum cryptography); and solutions to three Erdős problems in extremal graph theory.

Every proof was formally verified. All 10 proofs were formalized in Lean 4, a proof assistant that provides machine-checkable verification. There are zero 'sorry' gaps — mathematical shorthand for 'we're pretty sure this works but haven't proved it yet.' The Lean formalizations mean the proofs are independently verifiable by anyone with a computer, not dependent on trusting OpenAI or the model that generated them.

The cost was negligible. Approximately $2,000 in total token costs — roughly $200 per problem. Compare that to the cost of human mathematical research (years of PhD student and faculty time, grants, conferences) and the economics become startling.

A multi-agent architecture drove the results. Astra uses coordinated specialized sub-agents that decompose complex problems, assign sub-tasks, work in parallel, and cross-verify each other's outputs. This is not a single model answering questions — it's a system that orchestrates multiple models working together over extended periods.

This is part of a broader trend. DeepMind's AlphaProof Nexus autonomously solved 9 Erdős problems (as cheap as $7.50 per problem). Anthropic's Claude Mythos Preview discovered a lattice-structure vulnerability in NIST post-quantum candidate HAWK-256 (~$100K cost), forcing its withdrawal. Peking University's dual-agent framework overturned the Anderson conjecture (~19,000 lines of Lean code). Multiple labs are now producing original mathematical results with AI.

Your practical takeaway: The cost of solving frontier mathematical problems has collapsed from millions of dollars and decades of human effort to sub-$200 AI queries with machine-verifiable proofs. This doesn't mean mathematicians are obsolete — it means the bottleneck shifts from 'can we solve this?' to 'which problems are worth solving?' and 'how do we interpret and apply the solutions?' For businesses, the implication is that AI-driven scientific discovery is entering domains where formal verification is possible — cryptography, materials science, drug design, optimization — and the economic advantage will go to organizations that learn to ask the right questions and verify the answers.

The 10 Problems: What Astra Actually Solved

1. High-dimensional sphere packing (Cohn-Elkies bound improvement). The problem of packing spheres as densely as possible in high-dimensional space has been studied since the 17th century. The Cohn-Elkies bound (2003) provided the best known upper bound on packing density. Astra achieved the first improvement since 1978 in certain dimensions, producing a tighter bound using a novel linear programming construction.

2-3. Binary and spherical codes. Astra produced exponential improvements on the maximum size bounds for binary codes (error-correcting codes fundamental to digital communication) and spherical codes (configurations of points on a sphere relevant to signal processing and quantum information).

4. Non-sofic groups. A group is 'sofic' if it can be approximated by finite symmetric groups. The question of whether all groups are sofic — or whether non-sofic groups exist — has been open since roughly 2000. Astra constructed the first explicit example of a non-sofic group, settling a core open problem in geometric group theory.

5. Connes rigidity conjecture. This conjecture, dating to the 1970s, proposed that certain mathematical objects (group von Neumann algebras) uniquely determine the groups they come from. Astra disproved the conjecture — overturning a long-held belief in operator algebras.

6. Arithmetic circuit complexity. Astra proved new lower bounds on the size of arithmetic circuits needed to compute the permanent of a matrix — a central problem in computational complexity theory with connections to the P vs NP question. The formula bounds reached n⁴/log n, a significant advance.

7. Quantum parallel repetition. Astra proved an exponential parallel repetition theorem for general two-player quantum games — a result in quantum complexity theory that strengthens our understanding of how quantum strategies behave when repeated.

8. Closest Vector Problem (CVP) hardness. Astra proved polynomial-factor approximation hardness for the Closest Vector Problem — a lattice problem directly relevant to post-quantum cryptography. This result strengthens the theoretical foundation for lattice-based cryptographic schemes, which NIST has been standardizing as quantum-resistant alternatives.

9. Erdős problems #183, #146, #180. Three problems from Paul Erdős's famous collection: multicolor Ramsey numbers (#183) and two problems in extremal graph theory (#146, #180). These are 'Erdős problems' in the strongest sense — problems the legendary mathematician offered cash prizes for solving.

How Astra's Multi-Agent Architecture Works

The core insight: decomposition and coordination. Astra does not solve problems as a single monolithic model. It uses a multi-agent architecture where a coordinator agent analyzes the problem, decomposes it into sub-tasks, assigns each sub-task to a specialized sub-agent, collects and synthesizes the results, and iterates until a complete solution emerges.

Specialization. Different sub-agents have different strengths — some are optimized for algebraic manipulation, others for combinatorial search, others for formal proof generation. The coordinator routes each sub-task to the agent best suited to it, similar to how a research group leader assigns work to postdocs with different specializations.

Parallelism. Multiple sub-agents work simultaneously on independent sub-tasks, dramatically reducing the wall-clock time needed to explore a problem space. For the sphere packing problem, for example, one agent searched for linear programming constructions while another explored dual bounds — and they cross-validated each other's intermediate results.

Cross-verification. Before presenting a result as final, sub-agents check each other's work. This cross-verification step catches errors early — before they propagate into the final proof — and was critical to producing proofs that passed Lean formalization with zero gaps.

Extended operation. The system can run for extended periods — hours to days — on a single problem, maintaining coherence and making genuine progress rather than looping or degrading. This is a significant engineering achievement: earlier agent systems tended to lose the thread after a few dozen steps.

The Lean connection. The agents were trained to output Lean 4 code alongside natural-language reasoning. This means every step of reasoning is simultaneously expressed in a form that the Lean proof checker can mechanically verify. The 249-page paper is the human-readable explanation; the Lean code is the machine-checkable ground truth.

Why Lean Formal Verification Changes Everything

The trust problem with AI-generated mathematics. When an AI outputs a proof, how do you know it's correct? A human mathematician could spend weeks verifying a complex proof — and might miss an error. This is the trust problem that has historically limited AI's role in rigorous mathematics.

Lean solves the trust problem. Lean 4 is a proof assistant — software that mechanically checks every logical step of a proof. If Lean accepts a proof (i.e., compiles it with zero errors), the proof is mathematically correct. Period. No trust in the AI is required. No trust in OpenAI is required. The proof stands on its own, independently verifiable by anyone.

The significance of zero 'sorry' gaps. In Lean, 'sorry' is a keyword that means 'trust me, this step is true.' A proof with 'sorry' gaps is not a complete proof — it has holes. Astra's proofs contain zero 'sorry' gaps. Every logical step is fully formalized and machine-checked. This is a first for AI-generated mathematics at this scale.

The broader implication. Formal verification is not just about mathematics. The same approach — AI generates, formal verifier checks — applies to software correctness, hardware design, cryptographic protocol security, and any domain where formal specifications exist. Astra demonstrates the template: let AI explore the vast space of possible solutions, and let formal verification certify which solutions are actually correct.

The Lean ecosystem. The Lean mathematical library (Mathlib) now contains approximately 210 million lines of code and over 270,000 formalized theorems. This accumulated formalized mathematics is both training data for AI and verification infrastructure for AI-generated proofs — a virtuous cycle.

What $200 Mathematical Breakthroughs Mean for Business and Science

1. The cost structure of discovery is collapsing. A problem that might have required a $500,000 NSF grant, three years of a postdoc's time, and uncertain results can now be explored for $200. This does not make human researchers obsolete — it changes what they do. Instead of spending years on a single proof attempt, researchers can explore dozens of problem variants, let AI attempt proofs, and focus their expertise on selecting problems, interpreting results, and connecting discoveries to broader theory.

2. Formal verification is the new gold standard. Astra's results are credible not because OpenAI says so, but because Lean says so. In any domain where formal verification is possible — cryptography, chip design, aerospace software, financial contracts — AI-generated outputs paired with formal verification will become the standard for high-assurance claims.

3. The economic advantage shifts to problem selection. When the marginal cost of solving a frontier math problem drops to $200, the scarce resource is no longer problem-solving capability — it's knowing which problems are worth solving. Organizations that invest in domain expertise to identify high-value problems will capture disproportionate value from AI-driven discovery.

4. Post-quantum cryptography implications. Astra's CVP hardness result strengthens the theoretical case for lattice-based post-quantum cryptography at the same moment that Anthropic's Mythos Preview broke a competing NIST candidate (HAWK-256). AI is now simultaneously building and breaking cryptographic foundations — accelerating both sides of the security equation.

5. The template extends beyond math. Any domain with clear formal specifications — verifying that a chip design meets its specification, proving that a protocol cannot deadlock, certifying that a drug molecule binds to a target — can potentially follow the Astra template: AI proposes, formal verification disposes. The $200-per-problem economics of mathematics may soon apply to problems in engineering, biology, and finance.