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

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
100 attempts
1
10
100
1,000
10,000
about 460 attempts
1
10
100
1,000
10,000
1,000 attempts
1
10
100
1,000
10,000
10,000 attempts
1
10
100
1,000
10,000
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)
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
| Level | What improves | Weights change? |
|---|---|---|
| L0: answers | Candidate solutions within one run | No |
| L1: the agent’s scaffolding | Prompts, tools and workflow around a frozen model | No |
| L2: the improver | The procedure that makes the improvements | No |
| L3: the next model | Kernels, infrastructure and research work that train the next model | Yes, 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.
- The parent reads its benchmark logs and proposes one change to its own code.
- It makes the change; the model weights stay frozen.
- 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
| Claim | Status |
|---|---|
| Navier–Stokes | Claims 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. |
| ETH | Impagliazzo, Paturi and Ryan Williams have opened a community review, explicitly not a certification. No verdict yet on either claim. |
| October release | Three 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
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]