cd /news/artificial-intelligence/openai-s-gpt-6-2-astra-proves-a-math… · home › topics › artificial-intelligence › article
[ARTICLE · art-172187] src=alphasignal.ai ↗ pub= topic=artificial-intelligence verified=true sentiment=↑ positive

OpenAI's GPT-6.2 Astra Proves a Math Theorem No Computer Ever Could

OpenAI's GPT-6.2 Astra ranked first on Autoform-Hard, a 56-problem benchmark Vals AI assembled from research-level Lean tasks that all ten frontier models in Meta FAIR's original AutoformBench study failed to solve, solving 49 of 56 for 87.50% accuracy. Astra's extra solution formalized algebraist Agata Smoktunowicz's Gap Theorem in Lean via a new quantity called "capacity," skipping three deep results missing from Mathlib, in a 94-minute run of roughly 1,800 lines and $21.58 after the harness refused its early "unsolved" report. Claude Fable 5.2 and GPT-6.2 Sol tied at 85.71% (48 of 56), with Sol matching Fable at about one-third the average cost ($8.09 versus $23.21).

recommendation

Benchmark frontier models on holdout tasks none previously solved, and keep a harness that rejects premature "unsolved" reports, since Astra's winning proof came only after its first failure was refused.

more in playbook: Evals and testing for LLM apps
read8 min views3 publishedNov 18, 2026
OpenAI's GPT-6.2 Astra Proves a Math Theorem No Computer Ever Could
Image: Alphasignal (auto-discovered)

On a new benchmark of 56 math problems no earlier model could solve, GPT-6.2 Astra wrote the first known Lean proof of Smoktunowicz's Gap Theorem, using its own new route.

  • GPT-6.2 Astra wrote what is believed to be the first Lean proof of Smoktunowicz's Gap Theorem .
  • It built the proof on a new quantity called "capacity" and skipped three deep results missing from Mathlib.
  • Astra leads Autoform-Hard at 87.5%. Claude Fable 5.2 and GPT-6.2 Sol tie at 85.71%.
  • The run took 94 minutes, about 1,800 lines and $21.58, after the harness refused Astra's early "unsolved" report.
  • Autoform-Hard is 56 tasks from Meta FAIR's AutoformBench that no model in the original study solved.
  • Astra costs $8/$40 per million tokens on OpenAI's API . Sol matches Fable at a third of the cost.

Vals AI has published results for Autoform-Hard, a 56-problem benchmark assembled from research-level mathematics tasks that all ten frontier models in Meta FAIR’s original study failed to solve. OpenAI’s GPT-6.2 Astra ranked first with 49 correct solutions. Its extra solution formalized a theorem by algebraist Agata Smoktunowicz that, according to Vals, had no previous computer-checkable proof. Astra completed the task in 94 minutes, generated roughly 1,800 lines of Lean, and used a route absent from the published proof.

From 100 tasks to 56 holdouts #

Meta FAIR built AutoformBench from 341 Lean tasks drawn from 24 graduate- and research-level textbooks. Lean is a proof assistant: developers express a theorem as a type and supply a proof term that satisfies it. Lean’s small trusted kernel rejects any proof with a missing or invalid step. Formalization therefore requires spelling out details that textbooks routinely leave implicit.

Performance tracks the amount of missing formal infrastructure, with mathematical field proving a weaker predictor. Mathlib, Lean’s community library, often lacks the definitions and supporting lemmas required by these problems, so an agent must implement that groundwork itself. Accepted solutions in Meta’s study added a median of about 300 lines of Lean, while the longest required thousands.

  • Vals began with AutoformBench’s 100-task validation set and retained every problem that none of Meta’s ten tested models solved.
  • It removed three duplicates, leaving 56 tasks.
  • An audit corrected five tasks: three false statements and two packaging errors.
  • Each model received one agent run per task in the same sandbox, with Lean and a prebuilt Mathlib installation.
  • Every run had a three-hour limit and a $200 budget.

A one-theorem lead #

Autoform-Hard results reported by Vals AI
Model Solved Accuracy Average cost Average time
--- --- --- --- ---
GPT-6.2 Astra 49 of 56 87.50% $15.24 49m 28s
Claude Fable 5.2 48 of 56 85.71% $23.21 1h 7m
GPT-6.2 Sol 48 of 56 85.71% $8.09 1h 13m
Gemini 4 Carbon 40 of 56 71.43% $12.38 1h 55m
Gemini 4 Hydrogen 36 of 56 64.29% $23.25 2h 7m
Gemini 4 Argon 27 of 56 48.21% $25.74 1h 48m

Astra solved the same 48 tasks as Sol and Fable, then added the Smoktunowicz theorem for its one-problem lead. Sol matched Fable at roughly one-third of the average cost, while Astra recorded the lowest average runtime. Reflection’s Beam 1.0 and MiniMax-M3.1-Flash solved none of the 56 tasks.

The forbidden gap between n² and n³ #

For a finitely generated algebra, mathematicians can count the independent elements formed with words of length at most n. The Gelfand–Kirillov dimension, usually called GK dimension, describes how quickly that count grows. Smoktunowicz proved that a graded algebra without zero divisors cannot have growth strictly between quadratic and cubic. “Graded” means the algebra is divided into layers by degree; having no zero divisors means two nonzero elements cannot multiply to zero.

Smoktunowicz’s published proof relies on Bergman’s Gap Theorem, the Small–Warfield theorem, and a Riemann–Roch argument from algebraic geometry. Mathlib contains none of those results, and formalizing them would require substantial supporting work. Astra instead constructed a different argument.

Capacity avoids three missing theorems #

Astra’s proof assumes that the algebra’s growth lies inside the forbidden range and derives a slower growth rate, producing a contradiction. Its opening steps follow established methods, including construction of a ring of fractions. The later steps introduce a quantity called capacity.

Capacity measures how much a subspace grows when multiplied by a fixed generating piece, then takes the smallest growth over all containing subspaces. It behaves like a boundary size in a graph: combining subspaces does not cost more than treating them separately, and shifting a subspace preserves the measurement. This Python-like set analogy captures the basic shape of the idea:

def defect(U, S):
    return len({s + u for s in S for u in U}) - len(U)

S = {0, 1, 2}

print(defect(set(range(10)), S))    # 2
print(defect(set(range(1000)), S))  # 2: the boundary remains fixed
print(defect({0, 10, 20}, S))       # 6: scattered sets grow more

The decisive lemma shows that elements that do not raise capacity form a division ring, where every nonzero element has a multiplicative inverse. Controlling a finite set of generators then controls the full structure. Capacity cannot increase indefinitely without forcing quadratic growth, so it eventually reaches a plateau. Astra uses that plateau to derive a linear bound that contradicts the initial growth assumption.

Capacity resembles J. J. Zhang’s “volume difference” from work on lower transcendence degree, which Zhang suggested as a possible route to this gap. The argument also recalls Hamidoune’s isoperimetric methods in additive combinatorics. Vals has not found the minimization over larger subspaces or the resulting plateau argument in those papers and has asked specialists to assess the connection.

The harness rejects an early exit #

At about 47 minutes, Astra submitted a proof that covered the easier commutative case but left a sorry, Lean’s placeholder for an unproven step, in the general case. The grader rejected the submission, and Astra reported the task as unsolved. Because the harness blocks unsolved reports before an agent spends $20, the run continued after consuming only about $8. The log then shows nine minutes without a code change before the model switched approaches.

  • At minute 75, Astra created Capacity.lean with 25 declarations in a single command.
  • The file compiled after one correction pass.
  • The complete run finished in 94 minutes across 146 agent turns.
  • The run cost $21.58 at Astra’s list price.

Vals rebuilds each graded theorem from a trusted copy and requires its statement to match the original exactly. Proofs may use only Lean’s standard axioms: propext, Classical.choice, and Quot.sound. An independent kernel replays the result, blocking shortcuts such as native_decide and redefinitions of benchmark objects. Vals also reviewed the argument manually and published an annotated Lean proof explaining the code and its relationship to the published mathematics.

Tight budgets reward shorter routes #

Anthropic previously formalized Fermat’s Last Theorem with a swarm of Claude agents, producing 13 million lines of Lean over 11 days. That project closely followed an existing proof, and reviewers reported no new mathematics. Vals calculates that reproducing the same output within Autoform-Hard’s three-hour limit would require more than 1,000 lines per second. Under that constraint, an agent needs a compact argument rather than a large transcription effort.

Three constraints exposed by the result

  1. Library gaps can prompt proof search. Astra bypassed three unavailable theorems by constructing another route.
  2. Hard subsets preserve useful separation. The previous GPT-6 Astra already solves 82.4% of Meta’s341-task leaderboard , leaving the full benchmark with limited room to distinguish leading systems.
  3. Harness policy affects outcomes. The minimum-spend rule forced the run to continue after an incomplete proof and directly changed the result.

Run it, then read the caveats #

Developers can access GPT-6.2 Astra through the OpenAI API. The listed price is $8 per million input tokens and $40 per million output tokens, with a one-million-token context window and up to 128,000 output tokens. Vals configured the model at maximum reasoning effort. Astra ranks first on the Vals Science Index, seventh on the overall Vals Index, and near the middle of the tested field on finance and legal tasks.

AutoformBench is available in a GitHub repository under a CC BY-NC license. It includes clean-room grading workspaces and task-level results, allowing teams to run their own agents under comparable conditions.

Where the benchmark fits

  • Mathematicians can test formalizations of results whose prerequisites are missing from Mathlib.
  • Agent developers can evaluate systems against a kernel-backed grader designed to resist benchmark exploits.
  • Model buyers can compare accuracy, runtime, and cost under a shared harness. On these 56 tasks, Sol matched Fable at about one-third of the cost.

Astra failed seven of the 56 tasks, and the public reasoning record consists of OpenAI-generated summaries. Vals did not receive raw chain-of-thought logs. Algebraists still need to assess how much the capacity argument adds beyond Zhang’s work. The kernel-checked artifact establishes a narrower result: under a three-hour cap, the agent recovered from an incomplete formalization and produced a compact proof that passed exact-statement, axiom, and independent replay checks.

── more in #artificial-intelligence 4 stories · sorted by recency
── more on @openai 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/openai-s-gpt-6-2-ast…] indexed:0 read:8min 2026-11-18 · —