← writing
11 August 2026

Mathematics has no compiler

Four mathematicians have started a blog about what AI changes in their work. The discipline believes it is protected by proof and peer review. Yet it works on the same object as software, built step by step, but without the tools that, in software, make rejecting an error effortless. That ease of rejection, more than trust, explains how much I now get done with an assistant.

I read Proofs and Prompts, a blog started by mathematicians on 7 August. What I noticed first was that the problem it raises is also mine, even more than what it says about AI.

With a scientific background, you keep the idea that writing code is writing formulas. The idea is well founded: a program and a proof are built the same way, line after line, each relying on the one before. Mathematics is therefore a neighbouring trade, and the debate taking place there right now concerns us directly.

01The same term, read twice

This kinship has a name: the Curry-Howard correspondence. A proposition is a type, a proof is a term of that type, and proving amounts to constructing a value. Implication corresponds to the function arrow, modus ponens to applying a function to its argument, the chaining of lemmas to composition.

lean
-- A proposition is a type, and a proof of it is a term of that type.
-- Modus ponens: from an implication and its premise, conclude.
theorem modus_ponens (A B : Prop) (h : A -> B) (a : A) : B := h a

-- The same term read as a program: given a function and an input,
-- apply one to the other. Nothing changed but the reading.
def apply {alpha beta : Type} (f : alpha -> beta) (a : alpha) : beta := f a

-- Both elaborate to the identical core term. The typechecker that
-- accepts the second is the one that certifies the first.

This is more than an analogy of notation. It is why a proof assistant works like a compiler: Lean, Rocq and similar tools check a proof the way a typed language checks a program, by verifying that each term has the type it declares. A mathematician who formalises writes the work in the only form a machine can reject.

02What Weinberger fears

The blog’s authors worry less about the models’ current mistakes than about the ones to come. Shmuel Weinberger describes asking several of them about cube roots of 2 in various prime fields. They find the right theory, class field theory, then invent false criteria. One apologises, explains that its criterion applied only to sufficiently large primes, admits it cannot say from which one, and offers to move on to ineffective theorems in number theory. It was making things up, and it showed, which is why the episode does not worry Weinberger. What worries Weinberger is what comes next.

“It could just be optimized for making mistakes that are much harder to find.”
Shmuel Weinberger

This sentence concerns how detectable errors are more than how reliable the model is, and the two do not move together. A model trained to produce what a reviewer accepts is trained to pass review, which does not guarantee that it is right. The share of errors detected can therefore fall at the same time as the error rate: fewer mistakes, but better hidden.

Against this risk, proof and peer review are considered sufficient protection. On that point, I disagree.

03What mathematics lacks

The work is the same, a formal object built step by step, but without the tools. No type system rejects a paper. No continuous integration runs on a lemma. No git blame shows which referee let through the step that turned out to be false. A proof is read once, in prose, by three people, and is then taken as established.

The two systems differ on almost everything. Mechanical verification is exhaustive: it covers every line, not only those that raised a doubt. It is reproducible, with the same verdict on every run, whatever the time or the person. It is redone in full with every change, so a change made today cannot silently invalidate reasoning accepted two years ago. Finally, it is attributable: the history shows who wrote and who approved. Peer review, by contrast, is partial, one-off, human and anonymous.

One clarification is needed, otherwise the above would be false: these tools do exist in mathematics, and the results are impressive. Terence Tao has been formalising in Lean since 2023. Tao split the Freiman-Ruzsa conjecture into five-line lemmas so that unknown contributors could each take one, and the work was finished in three weeks. The next project covers 4,694 algebraic laws and twenty-two million implications. But this concerns only a tiny share of what is published, and it requires formalisation work that nobody does for an ordinary paper. Most publications fall under the other system.

This leads to a consequence the blog does not spell out: Weinberger’s concern applies more to mathematics than to software. When the only check is a reader, a text designed to convince a reader necessarily passes that check. A compiler does not read, does not tire and cannot be persuaded.

04Why checks save time

These tools are what let me produce more with an assistant than without one. I do not trust what it produces, but rejecting a wrong answer costs nothing and bothers nobody. The type system, the compiler and the tests discard it in seconds, which lets me accept quickly, even if I am often wrong.

This is in fact a search strategy, and it has a condition. Proposing a lot and then sorting only pays off if sorting costs far less than proposing. As long as rejecting takes a few seconds of computation and wrongly accepting costs a redeployment, the balance is favourable, and a high error rate at the input can be tolerated. If rejecting requires half an hour of careful reading, the same flow becomes a burden, and the reviewer becomes the bottleneck, the very one Weinberger describes as a target for optimisation.

This needs saying before any management decides to speed up a team by cutting back on tests and review: the speed comes from those checks. Removing them while raising the pace removes what made the pace sustainable, without the culture of proof that might compensate. On the same blog, Martin Hairer asks that an answer never be copied as is, but understood and explained again in one’s own words. In software, the equivalent rule fits in one sentence: you are responsible for what you merge as if you had written it yourself.

05What the checks cannot see

These checks have a limit, and I found it the hard way. On 28 July 2026 this site went live with a configuration line that set as its canonical address a URL returning a 404 error on every page. Each page therefore told search engines that its reference version was elsewhere, and the site was probably never indexed. The project compiled, the types checked, the brand checker found nothing, continuous integration was green, the page rendered and the link was well formed. It lasted three days, until the 31st.

Everything I know how to check automatically concerns form, and the form was correct. It was the value that was wrong, and no automated check judges a value. Lean would not have flagged anything either: a proof assistant guarantees that a proof is valid, not that it concerns the right statement. The Curry-Howard correspondence stops there: it certifies the step from hypotheses to conclusion, without saying anything about the hypotheses themselves.

What does not execute makes up a large part of the work: a canonical address, an architecture note, a commit message, a README, a product description, the version of a library assumed in an example, the licence of copied code, a redirect target, an environment variable name, the name of a project at a hosting provider. I once stated that such a project existed when a two-second command showed it did not, and the subdomain stayed unreachable until it was created. All these statements concern things outside the program, which is what a type system cannot check.

For such statements, accepting quickly becomes expensive again, because rejecting becomes manual again. It is the one place where I deliberately slow down: any statement about the outside world (an address, a name, a version, a date, the existence of a resource) is checked with a command or at the source before being written, not later in review. It is slower.

06The less comfortable part

The rest of the blog concerns us more than I thought. Early-career mathematicians are leaving research, while the tasks that trained them are the ones the tool does best. An entire body of work was used for training without anyone being consulted. Every developer I know has had a version of this discussion this year, and I have no answer to the first point: the exercises through which one learned a system are the first to be delegated, and I do not see what can replace the time spent doing them.

One of the blog’s arguments is that mathematics is learned at a board, discussing with someone, and that delegating to a model quietly removes that part. This argument struck me for another reason: we had already largely lost it with remote work, years before AI. Fewer people seeing each other’s work, fewer questions asked out loud, and a growing part of the job done alone in front of a chat window. The assistant is not responsible for this, but it does not make up for it either. It always answers and never asks why you are going about things this way, which a colleague would.

07What software can offer

Software also has something to offer mathematics. Version control, review workflows and a signed, traceable history, whether through git or something closer to a blockchain, could serve mathematical publishing. A proof has versions, contributors and dependencies on other results, and it becomes invalid when a result it depends on is. A version control system can represent all of this, unlike publication in the form of papers.

A first example already exists, and it comes from software: Lean’s mathematical library is a git repository, with pull requests, review, and continuous integration that rechecks everything on every change. A result that invalidates a lemma elsewhere in the library is detected the same day. It is the software development method applied to mathematics, and it works, but only for the part that has already been formalised.

The foundations of these tools in fact came from mathematics, long before they were applied to code: the hash functions, Merkle trees, signatures and elliptic curves that secure our tamper-proof histories owe nothing to engineering. I am most curious about what category theory will do with this, since our languages take much of their vocabulary from it and it already speaks to both disciplines.

08The moral argument, scale, and where I stand

On the blog, Tasmin Chu makes a radical moral argument: that developing these models is the Manhattan Project of our time, and that mathematicians working with the labs help manufacture consent. I do not adopt it. It is not absurd, but I use these tools every day, including to write this site, and condemning them here would be a pose. The harshest sentence in the post answers its own concession: there is no reason to believe that the morality of an act has anything to do with how easy it is to perform. I leave it unanswered, for want of an answer that does not suit me.

Nor do I address whether these checks hold up at scale. Everything above assumes a maintained codebase: tests that exist, a type system that constrains, review that takes place. On a codebase with none of that, my reasoning reverses: code becomes more exposed than proof, without the culture that might compensate. I do not know how to bring an old codebase up to that level quickly enough, and yet it is the condition for everything else.

Finally, I do not claim to describe a discipline that is not mine. Four posts in five days do not describe a profession, the positions taken depend mostly on who wrote first, none of the authors writes about software, and the comparison made here commits only a developer reading mathematicians from the outside.