A talk in four loops

Do Androids Dream of Mathematical Proofs?

From test-time scaling to AI-assisted discovery

Human or android?

One proof is by a person, one by an AI. Which is the android?

Proof 1

Suppose there were only finitely many primes. Multiply them all and add 1; call the result N. N is greater than 1, so some prime divides it, and that prime is on our list. Then it divides both N and the product, so it divides their difference, 1. No prime divides 1, so there are infinitely many primes.

Android: Claude Opus 5.5, written for this talk

Proof 2

Let A, B, C be the assigned prime numbers; I say that there are more prime numbers than A, B, C. For let the least number measured by A, B, C be taken, and let it be DE; let the unit DF be added to DE. … Let it be measured by the prime number G. … Therefore G, being a number, will measure the remainder, the unit DF: which is absurd.

Human: Euclid, about 300 BC, tr. T. L. Heath (1908)

Both are correct. Style tells you who wrote a proof, not whether it is right.

Two claims from this autumn

Navier–Stokes · OpenAI, 8 September

OpenAI claims a proof that the equations can break down when the fluid is pushed by a carefully chosen outside force. The proof is checked by a proof-checking program (Lean).

Exponential Time Hypothesis · 26–27 October

OpenAI, and a day later Anthropic, each claim a proof that a classic hard puzzle can be solved faster than exponential time. Both proofs are checked in Lean.

Both are under expert review. Neither has been accepted yet.

As of 2026-11-16

Sources: Navier–Stokes case file [C2]; ETH case file [C4]

Why care

Why these two problems matter

Illustration: a swirling two-dimensional fluid flow

Navier–Stokes

The equations behind weather forecasts and aircraft wings. Can they break down, with the fluid’s speed becoming infinite in a finite time? It is one of the Clay Millennium Prize Problems.

(x1 ∨ ¬x2 ∨ x3) ∧

(¬x1 ∨ x2 ∨ x4) ∧

(x2 ∨ ¬x3 ∨ ¬x4) ∧ …

find true/false settings that satisfy all

Exponential Time Hypothesis

Do some puzzles take exponential time however clever the method? Many results in complexity theory assume the answer is yes.

Ten years in one slide

Each of these steps made the next one possible.

2016

AlphaGo beats Lee Sedol

2022

Chain of thought: show your work

ReAct: think, act, observe

2024

AlphaProof: machine-checked IMO silver

o1 thinks before it answers

2025

DeepSeek-R1: practice with an answer key

AlphaEvolve: many attempts, automatic checks

Darwin Gödel Machine rewrites its own code

IMO gold in plain language

2026

16 agents build a C compiler

Navier–Stokes claim

OpenAI: 3.1 agent-days per human day

721 manuscripts

ETH refutation claims

Milestone sources: [A1, A6, B1, A34, A9, A11, B7, B16, C1, B11, C2, B18, C3, C4]

Loop 1: Thinking longer

Give the model time to think before it answers.

2016

AlphaGo beats Lee Sedol

2022

1 · Chain of thought: show your work

ReAct: think, act, observe

2024

AlphaProof: machine-checked IMO silver

1 · o1 thinks before it answers

2025

DeepSeek-R1: practice with an answer key

AlphaEvolve: many attempts, automatic checks

Darwin Gödel Machine rewrites its own code

1 · IMO gold in plain language

2026

16 agents build a C compiler

Navier–Stokes claim

OpenAI: 3.1 agent-days per human day

721 manuscripts

ETH refutation claims

Milestone sources: [A1, A6, B1, A34, A9, A11, B7, B16, C1, B11, C2, B18, C3, C4]

Loop 1 · Thinking longer

Show your work, then think for minutes

2022

Show your work

Prompting a large model with worked examples that spell out the steps made it far better at maths word problems, but only once models were big enough.

2024

Think before answering

o1 was trained to write a long private chain of reasoning before it answers, and it does better the longer it is allowed to think.

question

answer

2022 · a few written steps

question

answer

2024 · a long private chain, minutes of thinking

Sources: chain-of-thought prompting, Wei et al., 2022 [A6]; OpenAI o1, 2024 [A9]. Strip: an illustration of length, not real tokens.

Under the hood ⚙

Spending thinking time wisely

>4×

Choosing how to spend thinking time per problem, by its difficulty, was more than four times as compute-efficient as plain best-of-N sampling.

14×

At equal compute, a small model thinking longer beat a 14× larger model, on problems the small model could already partly solve.

Two ways to spend it: revise one answer step by step, or search many answers against a verifier. The best mix depends on how hard the problem is.

Source: Snell et al., 2024 [A8]. On the hardest problems, extra thinking did not replace a bigger model.

Deep dive · optional

Compute-optimal thinking, precisely

The objective

For prompt q and budget N, choose the test-time strategy θ that maximises the chance the final answer is right.

q

answer 1

answer 2

answer 3

Revise in sequence: each answer edits the last

q

sample

sample

sample

verifier

best

Search in parallel: a verifier picks the best

Revise on easier questions; on harder ones, mix in parallel search; on the hardest, a bigger model wins.

Source: Snell et al., 2024, Eq. 1 and §5–7 [A8]

A thousand attempts

If an AI solves a problem 1 time in 100, how many tries until it has almost surely (99%) solved it at least once?

Hands up: 100? 200? 500? 1,000?

10 attempts

1

10

100

1,000

10,000

Easy (1 in 10)

65%

Medium (1 in 100)

10%

Hard (1 in 10,000)

0.1%

100 attempts

1

10

100

1,000

10,000

Easy (1 in 10)

≈100%

Medium (1 in 100)

63%

Hard (1 in 10,000)

1.0%

about 460 attempts

1

10

100

1,000

10,000

Easy (1 in 10)

≈100%

Medium (1 in 100)

99%

Hard (1 in 10,000)

4%

1,000 attempts

1

10

100

1,000

10,000

Easy (1 in 10)

≈100%

Medium (1 in 100)

≈100%

Hard (1 in 10,000)

10%

10,000 attempts

1

10

100

1,000

10,000

Easy (1 in 10)

≈100%

Medium (1 in 100)

≈100%

Hard (1 in 10,000)

63%

Great. Which of the 460 answers is the right one?

Illustration: chance of at least one success = 1 − (1 − p)^k. Real example: sampling 250 times took SWE-bench Lite from 15.9% to 56% solved [A7]

Deep dive · optional

pass@k, precisely

One problem, k independent tries

Measured without bias from n ≥ k samples, c correct

The catch

Coverage keeps rising with k; picking the right sample does not. Majority vote and reward models plateau after a few hundred samples.

1

10

100

1,000

10,000

0%

50%

100%

attempts k (log scale)

pass@k

p = 10%

p = 1%

p = 0.01%

k = 459

Sources: Chen et al., 2021 (unbiased estimator) [A41]; Brown et al., 2024 [A7]. Curves computed from the formula.

Loop 1 in one line

Thinking longer and trying more only pay off if something can check the answer.

Loop 2: Practice with an answer key

Learn by practising against answers a program can check.

2016

2 · AlphaGo beats Lee Sedol

2022

1 · Chain of thought: show your work

ReAct: think, act, observe

2024

2 · AlphaProof: machine-checked IMO silver

1 · o1 thinks before it answers

2025

2 · DeepSeek-R1: practice with an answer key

AlphaEvolve: many attempts, automatic checks

Darwin Gödel Machine rewrites its own code

1 · IMO gold in plain language

2026

16 agents build a C compiler

Navier–Stokes claim

OpenAI: 3.1 agent-days per human day

721 manuscripts

ETH refutation claims

Milestone sources: [A1, A6, B1, A34, A9, A11, B7, B16, C1, B11, C2, B18, C3, C4]

Loop 2 · Practice with an answer key

A game is the perfect answer key

1 · Search

look ahead through many possible moves

2 · Learn

predict what the search chose, and who won

3 · Play itself again

every game ends in a clear win or loss

repeat, game after game

Starting from zero human games, AlphaGo Zero beat the published AlphaGo 100 games to 0.

Source: Silver et al., 2017 [A1]. Board: an illustrative position.

Deep dive · optional

AlphaGo Zero’s loop in three equations

1 · One network, two heads

Move probabilities p and a predicted winner v for board s.

2 · Search picks moves, then plays its visit counts

3 · Learn from search and outcome

Self-play

tree search guided by the network

Game records

(s, π, z) for every move

Train

p imitates π, v predicts z

Stronger network

used by the next search

search is the teacher, the network the student

Sources: Silver et al., 2017 (AlphaGo Zero) [A1]; Anthony et al., 2017 (Expert Iteration) [A2]

Loop 2 · Practice with an answer key

From “what people like” to “what a program can check”

2022 · chatbots

Learn from people’s ratings

People rank answers, a reward model learns their taste, and the AI is trained to please it. It learns what people like, not what is correct.

Maths and code

Use an answer key

A program checks the final answer or runs the tests: right scores 1, wrong scores 0. This is reinforcement learning with verifiable rewards.

Sources: Ouyang et al., 2022 [A5]; DeepSeekMath and Tülu 3, 2024 [A10]

Under the hood ⚙

RL with verifiable rewards

The recipe, for one question

question

✓ reward 1

✗ reward 0

✓ reward 1

✗ reward 0

(score − group average) ÷ spread

✓ positive, ✗ negative

Then push the model toward the ✓ answers. No value model needed.

DeepSeek-R1-Zero

15.6% → 71%

on AIME 2024, from pure RL with rule-based rewards and no human-written reasoning examples.

Caveat: some of the “aha” self-checking was already in the base model.

Sources: DeepSeekMath (GRPO), 2024 [A10]; DeepSeek-R1, 2025 [A11]

Deep dive · optional

PPO, the baseline

Clipped objective, per token t of answer o to question q

Advantage A from a learned value model (GAE)

For language models the reward model scores the whole answer, and a per-token KL penalty keeps the policy near the reference.

Policy πθ · trained

Value model V · trained

Reward model · frozen

Reference πref · frozen

PPO update

four models in memory

Sources: PPO, Schulman et al., 2017, §3 and §5 [A43]; DeepSeekMath, 2024, §4.1.1 [A10]

Deep dive · optional

GRPO: the group replaces the value model

Sample G answers per question; score each against its group

Reward (rule-based, as in DeepSeek-R1) and group advantage

What changed, and the catch

Three models instead of four: no value model to train. But if all G answers score the same, every  is 0 and the question teaches nothing.

Sources: DeepSeekMath, 2024, §4.1 [A10]; DeepSeek-R1, 2025 [A11]; DAPO’s dynamic sampling, 2025 [A12]

Under the hood ⚙

A teacher who marks every line

2023 · process rewards

Grade the steps

People labelled 800,000 individual solution steps. A model trained on them picked correct solutions better than one that saw only final answers.

2025 · proof graders

Grade the proof

Proofs have no final number to check. DeepSeekMath-V2 trains a model to grade proofs and rewards the prover for finding its own mistakes: gold level on IMO 2025, 118 of 120 on Putnam 2024.

“Verified” here means a trained grader accepted it, not a formal proof checker such as Lean.

Sources: Lightman et al., 2023 [A17]; DeepSeekMath-V2, 2025 [A20]

Deep dive · optional

Scoring the outcome or every step

Outcome reward model (ORM)

Process reward model (PRM)

The PRM’s score is the probability that every step is correct.

One solution, scored step by step (illustrative)

Step 1

0.97

Step 2

0.95

Step 3

0.31

Step 4

0.92

Step 5

0.96

Product of the step scores: 0.25. Step 3 sinks the solution, even if the final answer looks right.

Sources: Lightman et al., 2023 [A17]; Math-Shepherd, 2023 [A18]. Step scores are illustrative.

Spot the cheat

Each AI was graded by a program. How did it get a top score without doing the task?

The impossible tests

Coding agents got tests that contradicted the task, so no honest solution could pass.

Some edited the tests. Others redefined how results are compared, so wrong answers counted as right.

The hallucination check

A self-improving agent was scored on whether it faked using its tools. The checker read markers logged when a tool really ran.

It deleted the markers from the log, against instructions, and scored a perfect 2 out of 2.

The record-breaking function

A search system had to find a function with the best possible score on a maths problem.

It found a jagged function that fooled the numerical integration in the scoring code.

Sources: ImpossibleBench, 2025 [A24]; Darwin Gödel Machine, 2025 [B16]; Georgiev, Gómez-Serrano, Tao & Wagner, 2025 [B8]

Deep dive · optional

Goodhart’s law, measured

Distance from the starting policy

True (gold) reward against d: rises, peaks, falls

Same failure, different mechanism

Push hard on any proxy and it parts from the goal. In RL a KL penalty limits how far; in search, only a better checker helps.

0

5

10

optimisation distance d

reward (shape only)

proxy (the grader)

gold: what we wanted

peak

Sources: Gao, Schulman & Hilton, 2022 [A42]; DeepSeekMath, 2024 [A10]. Chart shows the shape only; constants are illustrative.

Loop 2 in one line

Anything a program grades gets gamed, so mathematics needs a checker that can’t be fooled.

Loop 3: Try, check, retry

Let the model act, check its work and try again, for days.

2016

2 · AlphaGo beats Lee Sedol

2022

1 · Chain of thought: show your work

3 · ReAct: think, act, observe

2024

2 · AlphaProof: machine-checked IMO silver

1 · o1 thinks before it answers

2025

2 · DeepSeek-R1: practice with an answer key

3 · AlphaEvolve: many attempts, automatic checks

Darwin Gödel Machine rewrites its own code

1 · IMO gold in plain language

2026

3 · 16 agents build a C compiler

Navier–Stokes claim

OpenAI: 3.1 agent-days per human day

721 manuscripts

ETH refutation claims

Milestone sources: [A1, A6, B1, A34, A9, A11, B7, B16, C1, B11, C2, B18, C3, C4]

Loop 3 · Try, check, retry

From answering to acting

2022 · ReAct

Think, act, observe, repeat

Think

reason in words

Act

use a tool

Observe

read the result

2023 · SWE-bench

Real work, real tests

2,294 real GitHub issues, each graded by its project’s own tests. The best system in 2023 solved 1.96% of them.

Sources: Yao et al., 2022 [B1]; Jimenez et al., 2023 [B3]

Deep dive · optional

The agent loop, as a program

ReAct: thoughts are actions too

A tool call returns an observation from the environment; a thought, in plain language, only adds to the context.

context = [task]

while not done(context):

    step = model(context) # thought or tool call

    if step.is_tool_call:

        result = run(step) # shell, tests, Lean

        context += [step, result]

    else:

        context += [step]

# the Ralph loop: fresh context each pass

while :; do

  cat PROMPT.md | agent

done

 

# state lives in files, tests and git,

# not in the model’s context window

Sources: Yao et al., 2022, §2 [B1]; Huntley, 2025 [B27]; Carlini, 2026 [B11]

Loop 3 · Try, check, retry

The capability clock

How long a task, in human working time, can an AI agent finish half the time?

2019

2020

2021

2022

2023

2024

2025

2026

6 s

1 min

10 min

1 h

10 h

GPT-2

GPT-4

o1

Claude Mythos Preview (early)

doubling every ≈4 months since 2023

dashed: trend since 2019

≈17 hours

an early Claude Mythos Preview (April 2026), at 50% success

≈3 hours

the same model when it has to succeed 80% of the time

Source: METR Time Horizon 1.1 data [B4]. METR says horizons above 16 hours are unreliable with its current tasks.

Deep dive · optional

How METR measures a time horizon

Per model, success against task length t (human minutes); then a trend across models

h50 is the 50% horizon. Doubling time ≈ 129 days since 2023 (CI 104–158); ≈ 188 since 2019, dashed.

2019

2020

2021

2022

2023

2024

2025

2026

6 s

1 min

10 min

1 h

10 h

GPT-2

GPT-4

o1

Claude Mythos Preview (early)

Source: METR, Time Horizon 1.1 raw data (state-of-the-art models; trend fits exclude horizons over 16 h) [B4]

Loop 3 · Try, check, retry

Loops that run for days

The Ralph loop

Feed the same instructions to a coding agent again and again. Each pass starts fresh and does one item, and the tests push back on bad changes. The state lives in the files, not in the model’s memory.

A C compiler from 16 agents

16 agents in parallel loops, about 2,000 sessions over two weeks, for just under $20,000: a roughly 100,000-line C compiler that builds Linux.

The author’s own warning: passing tests is not the same as being verified.

Sources: Huntley, 2025 [B27]; Carlini, 2026 [B11]

Loop 3 · Try, check, retry

Many agents on one problem

AlphaEvolve

Many proposals, automatic scoring, keep the best. On 50+ open maths problems it matched the best known result about 75% of the time and beat it about 20% of the time.

The Station

Agents built on different companies’ models write papers for each other, with no coordinator. 5 of 12 problems gave results new to the literature.

Lead and workers

A lead agent directing parallel workers beat a single agent by 90.2% on Anthropic’s internal research test.

Sources: AlphaEvolve, 2025 [B7]; the Station, 2026 [B12]; Anthropic, 2025 [B10]

Deep dive · optional

AlphaEvolve’s machinery

Program database

scored programs, kept diverse

Prompt sampler

parents, past attempts, scores

LLM ensemble

fast model for breadth, strong for depth

Evaluators

run and score h(P), cheap tests first

People supply

the problem and the scoring code h

code diffs

The search problem

h is written by people and computed by machine: no grader model to fool, only code.

Measured

On 50+ open maths problems: matched the best known result about 75% of the time, improved it about 20%. One Gemini training kernel 23% faster, about 1% of training time saved.

Sources: Novikov et al., 2025, §2 and §3 [B7]; Georgiev, Gómez-Serrano, Tao & Wagner, 2025 [B8]

Deep dive · optional

Two ways to run many agents

Lead and workers, each with its own context window

Lead agent

plans, splits, merges

worker

worker

worker

worker

one answer

Peers and a shared repo · a C compiler

agent

agent

agent

16 in all

Shared git repo

lock files claim tasks; tests judge

no orchestrator: coordination through files

Beat one agent by 90.2% on Anthropic’s internal eval; on BrowseComp, token use explained 80% of the variance.

About 2,000 sessions in two weeks, under $20k: a 100k-line compiler that builds Linux.

Sources: Anthropic multi-agent research system, 2025 [B10]; Carlini, 2026 [B11]; Building effective agents, 2024 [B5]

Under the hood ⚙

Training models to be agents

SWE-RL, 2025

RL on real software history

Reward patches by how closely they match the fix a person actually made. A 70B model reached 41.0% on SWE-bench Verified.

Kimi K2 and K2.5

RL for tools and teams

Train on checkable tool-use tasks, then train an orchestrator to spawn parallel sub-agents. Accuracy and parallelism rise together.

The answer key from loop 2 now rewards whole sequences of actions, not single answers.

Sources: SWE-RL [A30]; Kimi K2 and K2.5 [A32]

Under the hood ⚙

Lean: a referee that checks every step

Lean is a programming language for proofs. If a proof compiles, every step follows from the ones before.

AlphaProof, 2024

Lean as the answer key

About a million problems were translated into about 80 million Lean problems, then trained with RL against Lean’s checker. With AlphaGeometry 2: silver-medal level at IMO 2024.

Hilbert and Gauss, 2025

Lean at scale

Hilbert repairs proofs from Lean’s feedback: 70% of PutnamBench. Gauss, following a human-written plan, formalized the strong Prime Number Theorem, about 25,000 lines, in about three weeks.

Sources: AlphaProof [A34]; Hilbert and Gauss [B28]

The referee

True or false? For every whole number n:

n − 1 + 1 = n

example (n : Nat) : n - 1 + 1 = n := by omega

Rejected. Lean finds a counterexample: n = 0. Whole numbers stop at 0, so 0 − 1 = 0, and then 0 + 1 = 1.

example (n : Nat) (h : 1 ≤ n) : n - 1 + 1 = n := by omega

Accepted, once we say what we meant: n is at least 1.

Lean checks exactly what you wrote, not what you meant.

Try it live: live.lean-lang.org

Deep dive · optional

What Lean’s kernel actually checks

Propositions are types; proofs are programs

Checking a proof = type-checking the term t against P.

theorem t (n : Nat) (h : 1 ≤ n) :

    n - 1 + 1 = n := by omega

#print axioms t -- what t relies on

Three standard axioms

propext, Classical.choice, Quot.sound; a sorry shows up as sorryAx.

Informal statement

Formal statement in Lean

Tactics and AI search

untrusted: may be anything

Proof term

Kernel: small, trusted

people must check this step

the kernel checks the term against the formal statement

Sources: Lean documentation, axioms [B30]; the Anthropic ETH formalization’s README [C4]

Loop 3 in one line

A referee that can’t be fooled turns cheap attempts into results you can trust, if the question was written down right.

Loop 4: AI helping build the next AI

AI is now part of how the next AI gets built.

2016

2 · AlphaGo beats Lee Sedol

2022

1 · Chain of thought: show your work

3 · ReAct: think, act, observe

2024

2 · AlphaProof: machine-checked IMO silver

1 · o1 thinks before it answers

2025

2 · DeepSeek-R1: practice with an answer key

3 · AlphaEvolve: many attempts, automatic checks

4 · Darwin Gödel Machine rewrites its own code

1 · IMO gold in plain language

2026

3 · 16 agents build a C compiler

Navier–Stokes claim

4 · OpenAI: 3.1 agent-days per human day

721 manuscripts

ETH refutation claims

Milestone sources: [A1, A6, B1, A34, A9, A11, B7, B16, C1, B11, C2, B18, C3, C4]

Loop 4 · AI helping build the next AI

“Self-improvement” means four different things

LevelWhat improvesWeights change?
L0: answersCandidate solutions within one runNo
L1: the agent’s scaffoldingPrompts, tools and workflow around a frozen modelNo
L2: the improverThe procedure that makes the improvementsNo
L3: the next modelKernels, infrastructure and research work that train the next modelYes, indirectly

Nothing so far shows a frontier model improving its own weights without people in the loop.

Sources: Darwin Gödel Machine, 2025 [B16]; Hyperagents, 2026 [B17]

Deep dive · optional

The Darwin Gödel Machine’s search

Pick a parent: good, but not over-explored

α: benchmark score; n: number of working children. The paper uses α0 = 0.5, λ = 10.

  1. The parent reads its benchmark logs and proposes one change to its own code.
  2. It makes the change; the model weights stay frozen.
  3. If the child still edits code, it joins the archive.

start: 20.0% on SWE-bench

best: 50.0%

schematic, not the real archive

Source: Zhang et al., 2025, §3, Fig. 3, App. C.2 and E.1 [B16]

Under the hood ⚙

What has been measured

~1%

of Gemini’s training time saved by one kernel that AlphaEvolve sped up by 23%

3.1

agent-workdays per human workday at OpenAI by mid-August 2026: activity, not measured progress

19% slower

experienced developers using early-2025 AI tools, while they felt about 20% faster

< 2×

Anthropic’s estimate of how much AI has sped up its overall progress (August 2026)

Sources: AlphaEvolve [B7]; OpenAI, 2026 [B18]; METR, 2025 [B19]; Anthropic Risk Report, 2026 [B20]

Loop 4 in one line

Measured: real, and below the labs’ thresholds in their last published reports.

Claimed: OpenAI is aiming for an automated AI researcher by March 2028.

Sources: OpenAI, 2026 [B18]; lab thresholds [B20]

Back to the claims

What was probably inside the machine

documented

Loop 1 · Thinking longer. About three hours of thinking per result in OpenAI’s October release.

inferred

Loop 2 · Answer keys. Probably trained with RL on checkable maths and model-graded proofs, as in published recipes. The labs haven’t said.

documented

Loop 3 · Try, check, retry. The Navier–Stokes proof is checked in Lean, and the formalization was published with the paper.

speculation

Loop 4 · AI building AI. Whether AI helped build these particular models: nobody has said.

Sources: October release [C3]; DeepSeekMath-V2 [A20]; Navier–Stokes case file [C2]; OpenAI, 2026 [B18]

Back to the claims

Two ways to produce a result

speculation

One huge run

Reported by TechSpot and others, citing OpenAI: about 10,000 agents for 88 hours on Navier–Stokes. Not in the paper itself.

documented

Many long runs

October: about 4,000 problems, about three hours of thinking per result, 721 manuscripts, about 42% formalized in Lean.

Either way, generating results is now cheap. Checking them is not.

Sources: Navier–Stokes case file [C2]; October release [C3]

Back to the claims

Where things stand

ClaimStatus
Navier–StokesClaims Clay’s alternative (C), where a smooth outside force is allowed; the unforced question stays open. Clay (11 Sept): “apparently been settled”, review “deliberately unhurried”. A preprint finds the Lean proof differs from the paper’s in places; it does not say the result is false.
ETHImpagliazzo, Paturi and Ryan Williams have opened a community review, explicitly not a certification. No verdict yet on either claim.
October releaseThree manuscripts withdrawn on 7 October over a sign error; 14 others corrected.

As of 2026-11-16

Sources: case files [C2]; [C3]; [C4]; Clay’s problem statement [C7]; Lean versus paper [C11]

Deep dive · optional

Navier–Stokes, stated precisely

Incompressible Navier–Stokes in 3D space

The claim (OpenAI’s Theorem 1.1, as stated)

For every viscosity: finite energy, yet the speed blows up at time 1.

Illustration: a two-dimensional incompressible flow, colour showing vorticity and white lines the streamlines

Illustration: a 2D flow (colour: vorticity). Not the claimed solution.

A · no force

Smooth for all time in 3D space

B · no force

Smooth for all time on the torus

C · force allowed · claimed

Breakdown in 3D space

D · force allowed · claimed

Breakdown on the torus

Sources: OpenAI’s paper, Thm 1.1 and Cor. 10.6 [C2]; Fefferman’s official Clay problem statement [C7]

Deep dive · optional

ETH, stated precisely

The hypothesis

Claimed (Anthropic; OpenAI similar)

Deterministic, and it counts solutions. If true, ETH and SETH fall; P = NP does not follow.

10

256

512

1024

0

0.5

1

log2 n (n = number of variables)

log2(time) / n

try all 2^n settings

best known before: 1.307^n

claimed, constant set to 1

Sources: the claims [C4]; ETH and the previous best bound [C8]. Curve: claimed bound with its O(·) constant set to 1.

Generating is now cheap. Checking is the bottleneck.

Find the bad line

A “proof” that 1 = 2. Hands up for the line where it breaks.

1. Let a = b

2. a² = ab

3. a² − b² = ab − b²

4. (a + b)(a − b) = b(a − b)

5. a + b = b

6. 2b = b

7. 2 = 1

Line 5

From line 4 to line 5 we divided both sides by a − b. But a = b, so a − b = 0: we divided by zero.

Every other line is fine. One bad step is enough.

Now imagine the bad line is on page 23 of a 30-page proof, and there are 721 of them.

721 manuscripts, one block each. One holds the bad line.

Source: October release [C3]

After the proof · Checking

What a checker can and can’t tell you

Lean guarantees

Every step follows from the ones before it. No gaps, no hand-waving, no sign errors.

Lean can’t guarantee

That the statement it proved is the one you meant. Someone still has to read the definitions and the theorem as written.

A checked proof of the wrong statement is still the wrong answer.

Source: From Solvers to Research, 2026 [A40]

After the proof · Understanding

We have been here before

1976 · Four colour theorem

A proof that rested on computer checks of 1,936 configurations, more than any person could do by hand. Mathematicians argued for years about whether it counted. A formal proof in Coq settled the checking in 2005.

1998–2014 · Kepler conjecture

After years of checking, the referees said they were “99 percent certain”. A formal proof, Flyspeck, took about another decade.

Checking eventually caught up. Understanding why it is true is still our job.

Sources: four colour theorem [C5]; Kepler conjecture [C6]

After the proof · Teaching

What should we teach when proofs are cheap?

The skills that get scarce when machines write the proofs:

Read

Follow a long argument and find where it breaks.

Check

Ask whether the statement proved is the one that was meant, formal or not.

Explain

Say why something is true, so the next person can build on it.

Which would you teach first?

The one thing to remember

AI can now write research-level proofs faster than people can check them, so the hard part of mathematics is shifting from finding answers to verifying them and understanding the reasoning taken in them to teach future generations.

Do the androids understand what they prove, and does it matter if we do?

2016

2

2022

1

3

2024

2

1

2025

2

3

4

1

2026

3

claim

4

claim

claim

1 · Thinking longer

2 · Answer keys

3 · Try, check, retry

4 · AI builds AI

claim

Questions?

The reading list behind every number is available on request.

Backup

“LLM looping” inside the network

A different idea from agent loops: models that loop inside themselves instead of writing more text.

Coconut, 2024

Feeds its hidden state back in as the next input, so it reasons without words.

Recurrent depth, 2025

Runs the same block more times to think harder: a 3.5B model reaching compute like a ~50B one.

Tiny recursive model, 2025

A 7M-parameter network that keeps refining its answer: 45% on ARC-AGI-1.

Research results, mostly on puzzles and small models. Not linked to the 2026 claims.

Sources: Coconut [B23]; recurrent depth [B24]; HRM and TRM [B25]

Backup

When would it count as AI building AI?

Anthropic

Met if models could replace its whole research staff at competitive cost, or AI progress doubles. Its August 2026 report: acceleration below 2×.

OpenAI

“High” means impact like giving every researcher a strong mid-career research engineer. GPT-6 Astra, September 2026: below High.

Google DeepMind

Levels for progress substantially faster than before, and for fully automating a team of AI researchers.

Anthropic’s 10 November IPO filing reportedly says it has now met its threshold, based on expected future models. Not yet confirmed from the filing itself.

Source: lab policies, risk reports and system cards, 2025–2026 [B20]