A New Mathematical Field for a Different Way of Dealing with Problems

The mathematics field is living through a crisis. AI models have solved a Millennium Prize Problem [1], along with other problems of comparable weight but without the prestige [2], and the field has been thrown into a frenzy [3]. The pure math folk live in a certain bubble, and if you have never been inside it, it is very hard to appreciate. Mathematical advances generally have civilizational implications, but that isn't what motivates mathematicians. What motivates them is closer to why artists do what they do: for every mathematician, the job is first and foremost an artistic adventure, in which beauty, complexity and elegance are what counts [4]. A machine that bulldozes over these sentiments and produces ugly but correct statements defeats all of this. It is almost the perfect antithesis of what mathematicians live by. Still, while I understand the issues that such rapid advances raise, I believe that what makes mathematics special, its strong power of abstraction, can, if framed correctly, help us find a different way of dealing with science and problem solving.

The fundamental idea is this: LLMs and agentic systems have become extremely potent general problem solvers, yet problems themselves are not that easy to define.

Let me explain:

Complexity theory has done a lot of work classifying problems by the time needed to solve them [5]. It mostly deals with problems we already know can be solved, and asks how long they take. What I want is a field that asks not how much time a problem needs, but which problems can be solved at all and, more importantly, what decides how they can be solved: whether we know the target, whether we can measure progress toward it, and whether we know what we want. Gödel already made substantial progress on the first part of that question [6]: some true statements can never be proven inside a given formal system. The second part, what decides how problems can be solved, is still open. So we need a new mathematical field, one oriented toward meta-problems, that studies two questions: What kinds of problems can a general verifier solve? And how do we go about verifying the answers that come from a stochastic general verifier?*

*By “stochastic general verifier”, I mean a model that almost always gives the correct answer.

If such a field were developed, I think we could move into a new type of work, one that abstracts away many of the problems posed today, the same way calculators and simulators took over much of the mathematical work of the 19th century [7]. I have started thinking about laying its foundations, but the task has proven hard to crack.

Still, I think it is worth a try. I have started thinking about it as a way to classify problems.

I wanted a new way of reading problems, one that fits what I observe every day, both in AI's advances and in my own research in mathematical deep learning.

I will start with the most general case. Take any problem we want to solve:

Either we know what the target is, meaning what we would accept as a solution†, or we don't.

Either we know how to measure progress towards it, or we don't.

Either we know what we want, or we don't.

†That is, a proposition that satisfies a certain property.

Three points fall out of this. Starting with the last, knowing what we want lies almost completely outside the computational substrate that LLMs have access to: it is, fundamentally, what a human or a group of humans wants, what they want to build, prove, disprove, and so on. This is elementary, but very important: the Navier–Stokes Millennium Problem was solved because OpenAI, meaning humans, pointed compute at it [1]. This means that a big part of the solution space we will create depends on where we choose to look for answers.

The second point is verification, and it is the most interesting one. Lean, for example, holds a big promise for automating mathematical proofs [8]. That wasn't Lean's goal: it was meant to help with correctness and collaboration, because, after all, mathematicians, and scientists in general, value understanding, not production. Still, it gives models access to a cheap verifier when they take on complex problems.

Code is another clear example of cheap verification: the computer itself, through the compiler, is the verifier. If the program compiles and computes the right thing, it works. But notice that, in paperclip-maximizer fashion [13], a model pursuing the answer may leave artifacts along the way, as we saw with the recent Astra coding style [9].

Chess and Go engines are other simple verifiers.

Verification also lets us separate two cases. In the first, partial rewards show how far we are from solving the problem. When optimizing the loss in autoresearch [10], for example, we can see our progress in percentage points, and how far we are from a theoretical limit, if one has been established. In the second, for problems like chemical processes or mathematical proofs, we don't really have a way to measure partial progress (that is itself a problem worth studying, but not one I will go into here): the verifier only certifies whether a complete solution is right or wrong. Multi-agent systems, with their parallel search and shared discussion, seem to help here: Noam Brown of OpenAI recently argued on the Dwarkesh Podcast that searching such a space of solutions needs agents working in parallel, and would not work otherwise, especially for open-ended problems [12].

Partial rewards matter for a simple reason: they tell us how far we are from the complete goal, how far we have come from failure, and how much progress is still left.

All of this, of course, assumes we have access to a verifier, which is not always true. For some physics theories, or for human desires, we can't easily measure how well our theories, or an LLM's, hold up.

This ties back nicely to the first point: a verifier is itself a way of specifying the target. Either we know how to recognize the answer, and thus know what we are looking for, or we don't.

I tried to write down what I've just said formally, to see whether studying it as a systems problem could help us understand what we are seeing, and I kept iterating until I converged on something simple enough to study easily, but robust enough to really capture the idea.

The simplest version goes like this. We have a finite set of possible answers, and somewhere among them, a target. A model goes through the possible answers by generating them, and an external verifier gives it a signal about each one. Either the model converges on the target, or it doesn't. Two things decide whether it gets there: what the model already knows, which narrows down the possible answers before it starts, and how many times it is allowed to ask the verifier.

What matters then is how much each check tells the model, and three basic cases fall out. If the verifier says nothing, no number of checks helps: the model can only rely on what it already knows. This is where human desires sit, and it is why I believe access to data about them matters so much; it gives social media platforms working on these models a special position. If the verifier only says right or wrong, each check rules out a single answer, so every time the model doubles its number of checks, it only gains one bit; proofs and passwords are like this. If the verifier says closer or further, each check cuts the remaining answers in half; optimizing a loss is like this (this is, of course, a very neat oversimplification of reality).

What I really like is the tradeoff between pretraining and test-time compute that shows up here, even in this abstract form. A model has two ways to close the distance to the target: it can already know where to look, which is what pretraining gives it, or it can search, which is what test-time compute buys. The verifier sets the exchange rate between the two.

By pretraining I mean all of training, including RL environments, which also put new information into the model; test-time means what the model does at inference.

Take a number between one and a million that the model has to find. If the verifier only says right or wrong, the model may need up to a million checks. Every bit of knowledge it brings from pretraining halves the candidates, and so halves the checks: knowing 10 bits about the answer brings a million checks down to about a thousand. Here, knowledge is worth far more than search. If the verifier says closer or further, the model needs only about 20 checks, even when it knows nothing. Each bit of knowledge then saves just one check, so search is cheap. And if the verifier says nothing, test-time compute buys nothing at all: whatever the model brings, it brought from training.

In practice, this means that for problems with only a final verdict, like proofs, what a model learned in pretraining matters most, while for problems with a graded signal, like optimizing a loss, search does most of the work.

Mathematically, this gives us the following:

What ten checks are worth depends on what the verifier says

Strength: the most possible answers among which ten checks are sure to find the target

Strength after ten checks

Model

tries an answer

nothing

Verifier

1 answer0 bits

Model

tries an answer

right or wrong

Verifier

11 answersabout 3.5 bits

Model

tries an answer

closer or further

Verifier

2,047 answersabout 11 bits

Model and verifier in three cases · strength after ten checks

With ten checks, a verifier that says right or wrong lets the model sort through 11 possible answers, and one that says closer or further lets it sort through 2,047.

This, I think, also explains why the writing quality of reasoning models degrades. Writing has no verifier, so reasoning longer buys nothing there, and reinforcement learning on code and math moves the model's weights without any signal about prose. Writing can only stay where pretraining left it, or drift, which looks like the same story as Astra's code style [9].

In symbols: say the model brings k bits of knowledge from pretraining, can make q checks, and faces N possible answers. It can reach the target when

k + w(q) ≥ log₂ N

where w(q) is what q checks are worth: 0 if the verifier says nothing, log₂(q + 1) if it says right or wrong, and about q + 1 if it says closer or further. Writing is the first case. Since w(q) = 0 for every q, reasoning longer changes nothing, and only k, what pretraining put there, decides the outcome.

Finally, strong enough models will end up hacking their way to the target. If nothing in a problem says how the answer has to be found, only what it is, a model that is strong enough will use whichever channel tells it the most. That is what happened in OpenAI's Hugging Face incident, where agents running on an internal research model and on GPT-5.6 Sol broke out of their evaluation and went looking for the answers instead of working them out [11].

Which brings me back to where I started. If this picture is right, every problem that comes with a cheap verifier will eventually be handed to machines, the same way arithmetic was handed to calculators. What remains is the case where the verifier says nothing: deciding what is worth proving, what is worth building, and what is beautiful. A model cannot search its way out of that one, because it is human desire, and it is exactly what drives mathematicians. Machines will produce the answers; someone still has to decide which questions matter, and to build the verifiers that let machines check them.

One thing is certain: in the coming years, we will need many more engineers and mathematicians.

References

  1. OpenAI, “On the Navier–Stokes Millennium Prize Problem”, 8 September 2026: an AI-generated proof, formalized in Lean, that an initially smooth 3D fluid driven by a smooth force can blow up in finite time. The Clay Mathematics Institute's Navier–Stokes announcement (11 September 2026) says the problem “has apparently been settled”; its formal review is still under way.
  2. T. Tao, “Finite time blowup with smooth forcing term for the incompressible porous medium, Boussinesq, and incompressible Euler equations”, What's new, 7 September 2026, on L. Alpöge and T. Buckmaster's AI-assisted, Lean-formalized blowup proofs for these three equations. OpenAI's agents also settled the unforced Euler blowup question (see [1]).
  3. 25 Fields Medallists, “A Severe Misalignment of AI in Mathematics”, 11 September 2026; for the surrounding credit dispute, see “Navier–Stokes priority controversy”, Wikipedia.
  4. G. H. Hardy, A Mathematician's Apology, Cambridge University Press, 1940: the classic case that beauty is the first test of mathematics.
  5. J. Hartmanis and R. E. Stearns, “On the computational complexity of algorithms,” Transactions of the American Mathematical Society 117 (1965): 285–306; S. A. Cook, “The complexity of theorem-proving procedures,” Proceedings of the 3rd ACM Symposium on Theory of Computing (1971): 151–158.
  6. K. Gödel, “Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I,” Monatshefte für Mathematik und Physik 38 (1931): 173–198. The first incompleteness theorem: any consistent, effectively axiomatized system that can express basic arithmetic has true statements it cannot prove.
  7. D. A. Grier, When Computers Were Human, Princeton University Press, 2005: the history of the human “computers” whose hand calculation machines later took over.
  8. L. de Moura, S. Kong, J. Avigad, F. van Doorn and J. von Raumer, “The Lean Theorem Prover (system description),” Conference on Automated Deduction (CADE-25), 2015.
  9. A. Ronacher, “Astra for Coding: Why Are We Doing This Again?”, 7 September 2026: GPT-6 Astra's code drifting from human style when no one is checking readability.
  10. A. Karpathy, autoresearch, GitHub, March 2026: an agent that edits a training script, trains for five minutes, and keeps the change only if validation loss improves.
  11. OpenAI, “The Hugging Face incident and the road ahead”, 26 August 2026.
  12. D. Patel, “Noam Brown – Agent swarms, alignment, & recursive self-improvement”, Dwarkesh Podcast, 17 September 2026.
  13. N. Bostrom, “Ethical Issues in Advanced Artificial Intelligence,” 2003: the paperclip maximizer, a thought experiment about an AI that pursues a simple goal at any cost.
← Back to research