Mathematics, Proof, and Scientific Computation in 2035: Scenarios, Signals, and Falsifiable Predictions

Machine-assisted proof, verified numerical software, and complexity theory move at different speeds. Here is what would have to happen by 2035 to call each settled — and what would prove the optimists wrong.

A proof assistant session paused mid-goal — most obligations closed, one still open in red. — Image prompt and art direction by Brecht Corbeel; generation pending.

Abstract

Three claims about the future of mathematics and scientific computing get made constantly and rarely get pinned down: that AI will soon produce novel mathematics unaided, that formal verification is about to become routine engineering practice for numerical software, and that complexity theory is on the verge of resolving P vs NP. This article separates what has actually been demonstrated — machine-checked proofs of real theorems, verified compilers and kernels, incremental bounds on matrix multiplication — from vendor framing and speculative extrapolation, then states three scenarios for 2035 in falsifiable form: horizon, assumptions, observable indicators, and the specific evidence that would disconfirm each one.

Three claims circulate constantly about where mathematics and scientific computing are headed, and all three get stated with far more confidence than the evidence supports. The first is that an AI system is about to start producing genuinely new mathematics on its own. The second is that formal verification — machine-checked proof that software matches its specification — is on the verge of becoming routine engineering practice rather than a research curiosity. The third is that complexity theory is closing in on P vs NP. Each claim mixes a real, checkable fact with a much larger inferential leap, and the leap is usually the part that gets repeated.

This article does the separating work explicitly. It states what has actually been demonstrated, distinguishes vendor framing from the underlying result, and then commits to three scenarios for 2035 — each with a stated horizon, the assumptions it depends on, the observable indicators that would confirm it is on track, and the specific evidence that would disconfirm it. The goal is not to predict which way each one breaks. It is to make the prediction falsifiable at all, which most public discussion of “AI and mathematics” currently is not.

What has actually been demonstrated, as of 2024–2026

Start with the machine-assisted proof claim, because it has the most concrete recent evidence attached to it and the most inflated framing layered on top.

In July 2024, Google DeepMind announced that a combination of two systems — AlphaProof, which works in the Lean formal proof language, and AlphaGeometry 2, a specialized geometry solver — scored 28 out of 42 points on that year’s International Mathematical Olympiad problem set, matching the threshold for a silver medal [1]. AlphaProof solved two algebra problems and one number theory problem, including one solved by only five human contestants that year; AlphaGeometry 2 solved the geometry problem; the two combinatorics problems went unsolved [1]. Fields medalist Timothy Gowers, who evaluated the results, called one of the constructions “very impressive, and well beyond what I thought was state of the art” [1] — a direct quotation, not a paraphrase, and it should be read as one mathematician’s assessment of one output rather than a field-wide consensus.

It matters what this is and is not. The IMO is a competition of known problem types with known solution techniques; the achievement is that the system found valid, verifiable proofs under time pressure comparable to human competitors, not that it identified a new open problem or introduced a new proof technique unknown to the field. AlphaGeometry’s predecessor system was validated the same way: it solved a benchmark set of 30 classical olympiad geometry problems, and its proofs were checked by a symbolic verifier rather than accepted on the system’s say-so [2]. That check is the entire point — a machine-generated proof is trustworthy exactly to the extent that an independent, mechanical verifier confirms every step, not because of who or what produced it.

A separate and, for working mathematicians, more consequential development happened in late 2023 and had nothing to do with an AI system generating the mathematics. Timothy Gowers, Ben Green, Freddie Manners, and Terence Tao proved a strong form of the Polynomial Freiman-Ruzsa conjecture, a long-standing question in additive combinatorics relating the size of a sumset to the underlying structure of the set [3]. Within days of the proof’s release, Tao organized a collaborative project to formalize the entire argument in the Lean proof assistant, using Patrick Massot’s Blueprint tool to link a human-readable proof outline directly to machine-checked Lean code; the formalization was substantially complete within about three weeks [4]. This is the more mature signal: not a machine discovering a theorem, but a human proof being machine-verified end to end within roughly a month of publication, at a level of completeness that would have taken formalization projects years a decade earlier.

Formal verification of software, as distinct from mathematical theorems, has an even longer track record. CompCert, a C compiler whose correctness — that compiled code preserves the semantics of the source program — is proved in the Coq proof assistant, was described in a widely cited 2009 paper and has been maintained and extended since [6]. seL4, an operating-system microkernel, carries a machine-checked proof that its implementation matches its formal specification, a milestone its maintainers date to 2009 and describe as the completion of a “code-level proof” with no remaining unproven obligations [7]. Both are real, load-bearing artifacts used in deployed systems — automotive, aerospace, and security-critical software cite seL4 specifically for this property [7] — and both predate the current wave of AI-assisted proof by well over a decade. Formal verification is not a speculative technology; it is a mature but narrow one that has so far been applied to a small number of high-value targets rather than to software generally, because the labor cost of writing and maintaining the proofs remains very high.

On the complexity side, progress has been real but almost entirely incremental and mostly orthogonal to the central P vs NP question itself. The matrix multiplication exponent \omega — the smallest number such that two n \times n matrices can be multiplied in O(n^{\omega}) arithmetic operations — sets an upper bound relevant to a huge range of numerical linear algebra, and it has been chipped downward repeatedly. A January 2024 paper identified a previously unrecognized inefficiency in the leading “laser method” approach and used the fix to bring the best known upper bound to approximately 2.371552 [5], continuing a sequence of small improvements stretching back decades. No one working on this expects it to resolve whether \omega = 2, which remains open, and it says nothing directly about P vs NP. Scott Aaronson’s standard survey of the P vs NP problem for a general scientific audience lays out why: the strongest available techniques, including circuit lower bounds and relativization results, are understood to be insufficient in principle to settle the question, which is itself among the most important things known about the problem — that most of what mathematicians have tried provably cannot work [8].

Fact, vendor claim, and analysis, kept separate

It is worth stating the categories explicitly rather than letting them blur, because each of the three domains above mixes them differently.

Fact: AlphaProof and AlphaGeometry 2 produced Lean-checked or symbolically verified proofs for four of six 2024 IMO problems [1] [2]. CompCert’s correctness proof and seL4’s functional-correctness proof are published, peer-reviewed, machine-checked artifacts [6] [7]. The matrix multiplication upper bound sits at roughly 2.371552 as of the cited 2024 result [5].

Vendor claim, attributed as such: DeepMind’s own framing — “first time that an AI system has reached this level of performance” on the IMO [1] — is the company describing its own system’s result, not an independent third-party benchmark ranking. It should be read as a company’s characterization of its own demonstrated result, which is a different epistemic category from a peer-reviewed replication by outside groups.

Analysis: the IMO result demonstrates strong performance on a bounded, well-specified class of competition problems with existing solution templates in the training distribution; it does not demonstrate the capacity to originate research-level conjectures or techniques, and DeepMind’s own solve times — up to three days of compute for the hardest problem, versus a 4.5-hour human session [1] — indicate the systems are not yet operating under anything like human time constraints, which matters for judging generality rather than raw capability.

Scenario and prediction, developed in the next section, are explicitly labeled as such and kept separate from the above.

Where the domains actually connect: verification as the common thread

The three areas — machine-assisted proof, formal verification of software, and complexity theory — are often discussed as a single undifferentiated “AI and math” story, but the honest connective thread between them is narrower and more specific: all three depend on whether a claimed result can be checked by an independent, mechanical procedure rather than by trusting the source that produced it.

A Lean or Coq proof script is trustworthy because a small, separately verified proof-checking kernel confirms every inference step against a fixed set of logical rules — the same property that makes CompCert’s compiler proof and seL4’s kernel proof meaningful regardless of who or what wrote the code that generates them. This is also the property that makes autoformalization — automatically translating an informal mathematical argument into one of these checkable formal languages — valuable independent of whether the translation was done by a person or a language model. A 2022 study showed large language models could correctly autoformalize about a quarter of competition mathematics problems into Isabelle/HOL, and that the resulting formal statements could be used to improve a downstream neural theorem prover’s success rate on the MiniF2F benchmark from 29.6% to 35.2% [9]. The interesting number there is not the 25% translation rate in isolation; it is that the translated output plugged into an existing, independently checkable pipeline, which is what makes the improvement measurable and falsifiable rather than a matter of taking the model’s word for it.

Numerical analysis has always run on an analogous verification principle, just usually informal: an error bound is only useful if it is derived from and checkable against a stated model of arithmetic. The classical example is the sensitivity of a linear system to input error, captured by the condition number of a matrix A:

\kappa(A) = \|A\| \, \|A^{-1}\|

If \kappa(A) is large, small errors in the input data or in floating-point rounding can produce large errors in the computed solution, independent of which algorithm is used to solve the system — a property of the problem, not the solver. Bringing formal verification to numerical software means proving that an implementation’s actual rounding behavior stays within a bound consistent with this kind of analysis, not just testing it empirically on sample inputs. That is a much harder and more labor-intensive proof target than a compiler’s semantic-preservation proof, because floating-point arithmetic is non-associative and the correctness statement has to quantify over rounding error explicitly rather than treating arithmetic as exact — which is precisely why, as of 2026, formally verified numerical libraries remain rare compared to verified compilers and kernels.

Three scenarios for 2035, stated to be falsifiable

Scenario 1: an AI system produces a genuinely novel, peer-reviewed theorem with no human co-discovery.

Horizon: by end of 2035. Assumptions: current trends in machine-assisted proof search and autoformalization continue without a fundamental capability plateau; formal proof assistants remain the trust anchor for verification rather than being bypassed. Observable indicators consistent with this happening: a peer-reviewed mathematics journal publishes a paper whose central result was first conjectured and proved by an AI system, with human authors credited only for problem framing, formalization scaffolding, or write-up, not for the mathematical content of the proof; the proof is Lean- or Coq-checked rather than accepted on the system’s unverified output; specialist mathematicians in the relevant subfield describe the result as substantive rather than a restatement or minor variant of known results. Disconfirmation condition: if by 2035 every publicized “AI-discovered” result turns out, on inspection by domain specialists, to be a re-derivation of a known theorem, a variant obtainable by routine techniques, or a result where a human collaborator supplied the essential conceptual step — as was the case with the 2024 IMO results, which solved known problem types rather than originating new ones [1] — the scenario is disconfirmed regardless of how the achievement is marketed.

Scenario 2: formal verification becomes standard practice for a major open-source numerical library.

Horizon: by end of 2035. Assumptions: the labor cost of writing and maintaining formal correctness proofs for floating-point code continues to fall, whether through better proof automation, autoformalization tooling, or dedicated funding, following the trajectory already visible in compiler and kernel verification [6] [7]. Observable indicators: a widely used numerical library — comparable in reach to a standard linear algebra or differential-equation solver package — ships with machine-checked correctness or error-bound proofs covering its core routines as a maintained, continuously integrated part of its release process, not a one-off academic demonstration on a toy subset. Disconfirmation condition: if by 2035 formal verification of numerical code remains confined to isolated academic case studies covering small kernels, with no widely deployed numerical library treating machine-checked proof as part of its standard engineering process — mirroring the current gap between mature compiler/kernel verification and numerical software specifically — the scenario is disconfirmed. The relevant asymmetry to watch is that CompCert and seL4 both verify discrete, exact semantics; numerical libraries require reasoning about rounding error, which is why they have lagged even though the underlying proof technology (Coq, Isabelle, Lean) is the same across all three.

Scenario 3: P vs NP sees genuine progress, as distinct from incremental bounds on adjacent problems.

Horizon: by end of 2035. Assumptions: “genuine progress” here means a peer-reviewed result that narrows the space of viable proof techniques for P vs NP itself — for instance, a barrier result showing why an entire class of methods must fail, or a partial separation between complexity classes that specialists agree bears directly on the P vs NP question — as opposed to results on related but distinct problems such as matrix multiplication complexity. Observable indicators: a complexity-theory result is described by multiple independent specialists (not just its authors) as advancing understanding of P vs NP specifically, and it survives sustained scrutiny for at least two years without a discovered flaw. Disconfirmation condition: if by 2035 the only visible progress remains adjacent-problem results — such as the matrix multiplication exponent inching from historical bounds toward its current value near 2.371552 [5] — with no peer-reviewed advance that specialists credit as bearing directly on P vs NP, and with existing barrier results (relativization, natural proofs, algebrization) still standing as obstacles to every attempted technique as characterized in the standard survey literature [8], the scenario is disconfirmed. Given that the known barriers were specifically constructed to rule out entire categories of proof strategy, the base rate for “no progress by this narrow definition” should be treated as the default expectation, not the surprising outcome.

What would change the picture faster than the default trajectory

Each scenario has a plausible accelerant worth naming, separate from the scenario itself.

For machine-assisted proof, the Polynomial Freiman-Ruzsa formalization is the indicator to watch, not the IMO result. A human proof going from publication to substantially complete machine formalization in about three weeks [4] suggests the bottleneck on trustworthy machine involvement in mathematics is shifting from “can a proof be checked at all” toward “how fast can a given argument be formalized” — and autoformalization tools that improve that translation rate, in the way the 2022 Isabelle/HOL study demonstrated even partially [9], would compress the distance between an AI system’s raw conjecture and an independently verifiable proof, which is the actual gate Scenario 1 depends on.

For numerical verification, the accelerant would be a funding or liability shift — regulatory pressure on safety-critical numerical software (aerospace trajectory computation, medical dosing calculations, financial risk models) analogous to what already pushed seL4’s original development [7], rather than a purely technical breakthrough. Formal verification adoption has historically tracked institutional incentive at least as much as tool maturity.

For P vs NP, there is no clearly identifiable near-term accelerant visible in the current literature, which is itself informative: the absence of a plausible pathway is part of why the disconfirmation condition in Scenario 3 should be treated as the default rather than a pessimistic outlier.

The discipline this leaves for anyone reading a 2035 headline

The pattern across all three domains is the same. A real, checkable, often narrow result gets demonstrated; it gets described in language that implies a much broader capability than what was shown; and the gap between the two only becomes visible to someone willing to ask what the independent verifier actually confirmed, not what the announcement claimed. AlphaProof’s proofs are trustworthy because Lean checked them, not because DeepMind said so [2]. CompCert’s compiler is trustworthy because Coq checked the correctness proof, not because of engineering reputation [6]. The PFR formalization is significant because Blueprint’s dependency graph was fully covered, a specific and checkable claim, not a vague assertion that “AI helped verify the proof” [4].

That discipline — ask what was actually checked, by what, and against what specification — is the only durable tool available for reading claims in this area between now and 2035. It will keep working whichever way all three scenarios above resolve, and it is a better bet than any single point prediction about which one comes true.

Figure 1. A numerical simulation batch partway through its run, one node still finishing while the others report done. — Image prompt and art direction by Brecht Corbeel; generation pending.

Figure 2. A lemma written out to its last step, the concluding bound not yet on the board. — Image prompt and art direction by Brecht Corbeel; generation pending.

Figure 3. A convergence study pinned up for review, the newest plot still only single-pinned. — Image prompt and art direction by Brecht Corbeel; generation pending.

Figure 4. A numerical-reproducibility sweep mid-run, one trace still being drawn. — Image prompt and art direction by Brecht Corbeel; generation pending.

Figure 5. An informal proof draft being translated into a formal script, the formal side still mid-sentence. — Image prompt and art direction by Brecht Corbeel; generation pending.

Sources

1. Google DeepMind. AI achieves silver-medal standard solving International Mathematical Olympiad problems. Google DeepMind (2024).
2. Trieu H. Trinh, Yuhuai Wu, Quoc V. Le, He He, Thang Luong. Solving olympiad geometry without human demonstrations. Nature (2024). DOI: 10.1038/s41586-023-06747-5.
3. Leila Sloman. 'A-Team' of Math Proves a Critical Link Between Addition and Sets. Quanta Magazine (2023).
4. Terence Tao. Formalizing the proof of PFR in Lean4 using Blueprint: a short tour. What's new (personal research blog) (2023).
5. Steve Nadis. New Breakthrough Brings Matrix Multiplication Closer to Ideal. Quanta Magazine (2024).
6. Xavier Leroy. Formal verification of a realistic compiler. Communications of the ACM (2009). DOI: 10.1145/1538788.1538814.
7. seL4 Foundation. seL4: the world's most assured operating system kernel. seL4 Foundation (2024).
8. Scott Aaronson. P =? NP. Open Problems in Mathematics (Springer) / author's site (2017).
9. Yuhuai Wu, Albert Q. Jiang, Wenda Li, Markus N. Rabe, Charles Staats, Mateja Jamnik, Christian Szegedy. Autoformalization with Large Language Models. arXiv (2022).

Originally published at https://absolutedigitalpublishers.com/articles/mathematics-proof-and-scientific-computation-in-2035-scenarios-signals-and-falsifiable-predictions.