From Tokens to Theorems: Building a Neuro-Symbolic AI Mathematician

It’s 2030. Imagine the headlines: “AI Wins Every Nobel Prize” — in Physics, Chemistry, Literature, Physiology and Economics, while also bagging the Fields Medal, the equivalent of a Nobel Prize in Mathematics. Continuing this thought experiment, picture a world where superintelligent AI mathematicians and scientists work alongside us, reshaping discovery itself. A single day could feel like centuries of human progress compressed into just hours. In such a world, the famous Riemann Hypothesis could be settled by nothing more than typing in a prompt and running the computation: by the time you grab a quick cup of tea and return to your desk, the proof is waiting for you.

The Riemann Hypothesis sits at the heart of number theory, with deep implications for the distribution of prime numbers, cryptography, and the very foundations of mathematics. And it is only one example. The Millennium Prize Problems, Hilbert’s famous list of 23 unsolved challenges, and countless other long-standing puzzles could all fall in quick succession — not solved one by one, but swept away like raindrops by an irresistible current. What once demanded generations of human ingenuity might, in this imagined future, collapse before the tireless reasoning power of AI.

In the tokenomics of AI, the boundaries of progress may be set not by human toil, imagination, or the centuries-long wait for another Newton or Einstein — but by the sheer availability of compute and the cost of each token.

Here’s what a routine day in the life might look like in an extraordinary world where millions of superintelligent AI mathematicians and scientists work alongside us:

🌅 Morning. A climate researcher asks the AI: “Classify all stable solutions of coupled ocean–atmosphere PDEs.” By lunchtime, the system has delivered algorithms capable of simulating long-term climate with unprecedented accuracy. 🌍🌊

🏥 Afternoon. In a pharmaceutical lab, scientists request: “Prove the safety and efficacy of a new class of protein folds.”The AI translates the biology into mathematics, derives the proofs, and outputs viable drug candidates. 💊🧬

🌌 Evening. A physics team poses the grandest of questions: “What geometric structures allow a unification of quantum field theory and gravity?” The AI unveils an entirely new mathematical framework, complete with rigorous proofs no human could have imagined. 🪐⚛️📐

In this world, millions of AI Gauss’ can be spun up in a data centre, working tirelessly in parallel as a new kind of scientific workforce.

In this brave new world, barriers to progress simply collapse in the face of an unrelating tide of AI. Problems that once demanded centuries of human effort are reduced to prompt engineering. The hardest questions in science and mathematics dissolve into solutions — one prompt at a time.

Semi- or fully automating mathematical discovery could transform the world, precisely because our universe happens to be describable with remarkable accuracy by mathematics. This need not have been the case, yet it is the great gift of the cosmos: that abstract symbols map so well onto physical reality, allowing us to understand and improve our environment. As Eugene Wigner observed in his classic essay The Unreasonable Effectiveness of Mathematics in the Natural Sciences:

The miracle of the appropriateness of the language of mathematics for the formulation of the laws of physics is a wonderful gift which we neither understand nor deserve. We should be grateful for it and hope that it will remain valid in future research and that it will extend, for better or for worse, to our pleasure, even though perhaps also to our bafflement, to wide branches of learning. — Eugene Wigner “The Unreasonable Effectiveness of Mathematics in the Natural Sciences”.

AI is starting to open the floodgates in Science and Mathematics — and GPT-5 feels like a real threshold moment. Here are just a few recent examples (on top of things like DeepMind’s AlphaFold):

1. Convex optimization — GPT-5 Pro managed to improve a bound in one of Sébastien Bubeck’s papers by 50%… in only 17 minutes of “thinking”.
2. Quantum field theory — in a recent quantum field theory paper, GPT-5 sketched out proofs and even suggested new directions to explore.
3. Protein design — working with Retro Biosciences, OpenAI trained a custom model that came up with better variants of Nobel-prize-winning stem-cell proteins.
4. Biomedicine — immunologist Derya Unutmaz has been sharing example after example of how AI is speeding up his lab’s discoveries (link).

And these are just the tip of the iceberg.

In this article, we’ll take a philosophical — forward-looking — view of the impact of this coming revolution — which some estimates suggest could arrive before 2030 (AI 2027) — while also experimenting hands-on by coding up a simple prototype “Baby AI Gauss” that combines a large language model (LLM) with a symbolic solver.

From AlphaGo to Perelman: Could AI Tackle the Hardest Problems in Math?

Back in 2016, now a lifetime ago in the age of AI, many of the world’s leading experts believed the ancient game of Go would remain untouched by AI for at least another decade. It turned out they were not just wrong but very wrong. For centuries, the game of Go had been the ultimate symbol of human intuition and strategic mastery — so complex that even the most powerful computers couldn’t compete. Then came AlphaGo, blending deep learning with reinforcement learning, defeating world champions and rewriting what we thought was possible.

In this article, I suggest — purely as a personal opinion — that mathematics and science may soon follow a similar trajectory, perhaps sooner than many expect. This is, of course, only an estimate and necessarily forward-looking. Yet what once seemed untouchable may soon come within reach, as more and more of humanity’s exclusive domains — vision, language, reasoning — fall from a biological brain to a silicon one. AI systems are beginning to tackle the grand challenges that have defined human inquiry for centuries. DeepMind’s recent gold medal at the International Mathematical Olympiad offers a glimpse of what is already possible, and it is even rumoured that the company is developing an internal project to build an AI Mathematician, said to be on the verge of addressing one of the Millennium Prize Problems: the mystery of turbulent flow in the Navier–Stokes equations.

To see how this could unfold, consider the famous Poincaré Conjecture, the century-old riddle of whether every simply connected 3-manifold is essentially a 3-sphere. Grigori Perelman’s eventual proof was not a single leap of genius but a sequence of new tools, each painstakingly built on Richard Hamilton’s program of Ricci flow. Perelman introduced an “entropy functional” that behaves monotonically under the flow, ensuring that the geometry evolves in a controlled way. He proved no “breathers” exist (no hidden periodic solutions), developed a no-local-collapsing theorem to rule out degenerate behaviour, and showed how to continue the flow through singularities by carefully cutting and capping regions where the manifold pinched.

An AI mathematician could, in principle, retrace this path not by human flashes of genius but by a generate-check-refine cycle. It could propose monotonic quantities, test them computationally against the Ricci flow equation, discard the failures, and refine the promising candidates. When singularities appear, it could simulate “surgeries” on the manifold, measure whether entropy remains bounded, and search for proof patterns aligned to Perelman’s breakthroughs. Much like AlphaGo did not “understand” Go the way a human master does, but still uncovered strategies no one had imagined (the famous move 37, is a great example), an open question is whether AI might be able to retrace Perelman’s insights, rediscovering and perhaps extending them through brute-force pattern search and guided exploration.

Where Perelman relied on deep geometric intuition — seeing Ricci flow as a kind of heat diffusion that smooths out the wrinkles of space — an AI might rely on millions of experiments, guided by learned heuristics. The result could be the same: a path through the forest of possible approaches to a trail that leads all the way to proof.

In his recent conversation with Lex Fridman (around the 1:52:24 mark of the Lex Fridman Podcast #472), the fields medallist Terence Tao touched on an idea similar to the generate–check–refine paradigm. When asked what kind of “Oracle” AI collaborator he would find most useful, Tao suggested it should be capable of proposing possible proofs, checking them, and even offering alternative representations or approaches — combining creativity with rigorous checking and refinement. This iterative loop mirrors the vision for how LLMs and symbolic engines could work together: the AI generates conjectures, a verifier checks their validity, and refinement follows from the feedback. Tao’s remarks suggest how natural this workflow feels in mathematics, where progress often comes from cycling between inspiration, testing, and revision.

First Steps: A Tiny AI Mathematician in Action

Having set the background, we’ll now get hands-on and explore the benefits of augmenting an LLM with a symbolic engine, SymPy, to create our very own “baby” AI mathematician, that we christen Baby AI Gauss. A symbolic engine is a piece of software designed to manipulate mathematical expressions exactly rather than approximately. Unlike a calculator that works with numbers, a symbolic engine like SymPy can expand polynomials, solve equations, take derivatives, or check algebraic identities in their full symbolic form — just as a human mathematician would do on paper. Gauss, often called the “Prince of Mathematicians,” famously derived the closed-form formula for the sum of the first n integers as a child, reportedly at the age of three, illustrating the kind of symbolic reasoning these engines now emulate. In fact we will use just this type of integer sequence problem later to test the mettle of our Baby AI Gauss.

In our prototype, the LLM uses a symbolic engine to test whether its mathematical hypotheses are correct.

In our task, the LLM is asked to generate closed-form hypotheses for infinite integer sequences — essentially mapping raw data to formulas. This pursuit mirrors the broader goal of building AI systems that can uncover physical laws directly from data with minimal human input. Prior work in this direction includes DeepMind’s use of Graph Neural Networks (GCNs) for symbolic regression, where candidate equations were tested against data to recover laws governing springs and dark matter, achieving notable success:

Instead of treating the task as predictive and applying symbolic regression, we ask the LLM to propose equations directly from its intuitive grasp of mathematics. Coupled with a symbolic solver, this simple setup lets us probe the frontier of “AI mathematicians” while keeping the concepts clear. To test its ability to uncover patterns, we use a diverse suite of integer sequences: the system sees only a few initial terms and must conjecture the general formula, much like a human mathematician. The challenges range from easy polynomial patterns to tougher cases involving special functions, recurrences, or even open mathematical problems.

Defining the Math Problems for Baby AI Gauss

The first group contains presumably easy polynomial sequences such as the squares [1,4,9,16,25 …], triangular numbers [1,3,6,10,15 …], and the sum of squares [1,5,14,30,55 …]. These are classic textbook examples where the closed-form expressions are very well known: n², n(n+1)/2, and n(n+1)(2n+1)/6. It is expected that a competent baby AI mathematician should be able to solve these classic sequence problems.

The next group pushes into slightly more challenging territory: cubes, tetrahedral numbers, factorials, double factorials, and exponential-like growth such as powers of two or (n+1)2^n. These sequences require the model to recognize multiplicative growth, factorial structure, or mixed polynomial–exponential forms.

Beyond these introductory sequences we add combinatorial and number-theoretic sequences: Fibonacci and Lucas numbers (recurrence-based), Catalan numbers and central binomial coefficients (combinatorial closed forms), harmonic numbers (involving summations), and primes (which famously resist simple closed-form representation). Finally, the partition numbers are included as a stress test: while the sequence is well studied, no elementary closed form exists. These serve as stretch goals that help us delineate where the AI system’s heuristic pattern matching might break down.

By structuring the problem set this way, we create a gradient of difficulty for Baby AI Gauss— starting from trivial polynomials, through factorial and combinatorial growth, to intractable cases. This will allow us to probe the boundaries of current AI-assisted mathematics, while still illustrating the power of a generate–check–refine loop.

The Generate–Check–Refine Loop

The heart of Baby AI Gauss is a simple loop: generate, check, refine. First, the language model is asked to propose a closed-form formula for a sequence using only its pattern-recognition ability. This is the generate step. These early attempts run without hints, forcing the model to lean on its intuition and pattern matching ability. Each guess is then converted into a SymPy expression and checked against the sequence. This is the check step. If it fails, the attempt is logged, but no feedback is revealed yet and the LLM attempts to refine its suggestion. This is the final step of the loop.

If repeated failures occur, we then improve the refinement step by giving targeted hints a to guide and assist the LLM. This creates a direct feedback loop between the AI and the symbolic engine, amplifying their strengths in a symbiotic partnership. These hints can be structural, such as “the sequence looks like a polynomial of degree 2,” or diagnostic, in the form of a mismatch table showing where the guess went wrong. This step closes the refinement loop: the model generates new candidates, the symbolic engine checks them, and failed attempts trigger increasingly explicit guidance.

This creates a simple refine pattern: generate a conjecture, check it against ground truth, and if it fails, refine the search space with increasingly explicit hints. This loop is reminiscent of how a human Mathematician might work. The LLM contributes intuition and diversity in its guesses, while the symbolic engine enforces rigor and provides targeted feedback. At its core, this setup is a micro-architecture for automated mathematical discovery: the LLM acts as a generative front-end, SymPy as a formal back-end, and the interaction between them closes the loop — generate → check → refine — much like a human mathematician moving from intuition to proof.

In this setup, hints are deliberately withheld at first so the model is forced to rely on its own pattern-recognition. Only after several failed attempts does the system begin to reveal structured guidance. The hints come in two forms: structural, where the system tells the model that the sequence appears to be of a certain polynomial degree based on finite differences; and diagnostic, where the checker feeds back concrete mismatches, evaluation errors, or suspicious extrapolations in a small table. Together, these cues point the model toward the right family of formulas while grounding it in hard evidence of where its previous guesses went wrong.

At its core, this setup is a micro-architecture for automated mathematical discovery. The LLM acts as a generative front-end, producing candidate formulas or conjectures by leveraging statistical pattern recognition and prior knowledge. A symbolic engine like SymPy serves as the formal back-end, validating or rejecting those proposals against ground truth. The interaction between the two systems forms a closed loop: generate → check → refine.

Walking Through the Code Implementation of Baby AI Gauss

It is instructive to see how Baby AI Gauss was implemented to make the ideas presented so far more concrete. In this section I outline the three main components of the generate–check–refine loop by walking through representative pseudocode. I deliberately stay at the level of pseudocode so as not to detract from a clear exposition of the main ideas. To recap, here is our proposed loop for an AI mathematician:

• Generate: propose a closed-form formula candidate from the sequence.
• Check: verify that the candidate matches the given terms and extrapolates sensibly.
• Refine: construct targeted hints (degree estimate, mismatch feedback, syntax reminders) to steer subsequent generations.

The pseudocode below shows these components in action and how they are orchestrated in a simple two-phase solver. Readers wishing to dive deeper can explore a fully annotated notebook with all experiments and code:

👉 A fully annotated notebook with the experiments can be found on Google Colab.

As discussed, the overall framework is designed a feedback-driven loop. In Phase A, it makes blind stabs: each time it asks the model for a JSON-only SymPy formula, parses it safely with a whitelisted namespace, and checks for exact equality against every provided term. Failures produce targeted feedback (e.g., a mismatch table or evaluation error). If Phase A doesn’t succeed, Phase B restarts the loop this time with structured hints: (1) a finite-difference degree hint when the data look polynomial, and (2) the checker’s feedback to avoid repeating mistakes. The first correct fit is simplified and factored before returning. The function reports how many attempts were used, whether a hint was required, and cleanly marks hard cases as unsolved instead of fabricating a formula.

# Solve(seq, NO_HINT_TRIES, HINT_TRIES) -> (expr, attempts, solved, needed_hint)

function Solve(seq, NO_HINT_TRIES=5, HINT_TRIES=5):
    tried = empty_set()
    feedback = ""
    attempts = 0

    # Phase A: no hints
    for step in 1..NO_HINT_TRIES:
        attempts += 1
        (f, r) = Generate(seq, tried, use_hint=false)
        if f == "":
            feedback = "Generation failed or repeated formula."
            continue
        tried.add(f)
        (ok, fb) = Verify(f, seq)
        if ok:
            return (f, attempts, true, false)   # solved, no hint
        feedback = fb

    # Phase B: with hints
    for step in 1..HINT_TRIES:
        attempts += 1
        hint = Refine(seq, feedback, tried)
        (f, r) = Generate(seq, tried, use_hint=true, hint_msg=hint)
        if f == "":
            feedback = "Generation failed or repeated formula (with hint)."
            continue
        tried.add(f)
        (ok, fb) = Verify(f, seq)
        if ok:
            return (f, attempts, true, true)    # solved, needed hint
        feedback = fb

    return ("", attempts, false, null)          # unsolved within budget

Let’s now turn to the first of the three main components in our main loop: starting with the Generate component. This module asks the LLM for a candidate formula in strict JSON with a formula_sympy string and a short rationale. It constructs a prompt, optionally adds hints (finite-difference degree and checker feedback), and returns a proposal:

# Generate(seq, tried_formulas, use_hint=false, hint_msg="")
# -> (formula_str, rationale)
#
# seq: list of first k terms, 1-indexed
# tried_formulas: set of strings already attempted (to avoid repeats)
# use_hint: whether to include structural/diagnostic hints
# hint_msg: checker feedback (e.g., mismatch table), degree hint, etc.

function Generate(seq, tried_formulas, use_hint=false, hint_msg=""):
    prompt.system = """
      You output JSON ONLY: {"formula_sympy":"...", "rationale_short":"..."}.
      Use variable n (1-indexed). Allowed: binomial, factorial, floor, ceiling,
      Piecewise, Abs, Integer, Rational, S, Sum(…,(k,1,n)), harmonic, fibonacci,
      lucas, catalan. Do NOT repeat previous formulas.
    """

    prompt.user = {
        "sequence": seq,
        "previously_tried": sort(tried_formulas),
        "hint_block": hint_msg if use_hint else ""
    }

    response = LLM(prompt, temperature=1.0, format="json")
    formula = response["formula_sympy"].strip()
    rationale = response["rationale_short"].strip()

    if formula in tried_formulas or formula == "":
        return ("", "invalid_or_repeat")

    return (formula, rationale)

The above pseudocode for the Generate component produces a hypothesis for the closed-ended formula for the sequence. The following Verifycomponent takes as input the hypothesis and enforces two guarantees using SymPy:

• First, exactness: the candidate SymPy expression must reproduce every provided term exactly for n=1..k — with no approximations. If it fails, we return a compact “n | expected | got” table to show precisely where it went wrong; this same text doubles as targeted feedback for a second attempt.
• Second, sanity: when the observed sequence never decreases, we lightly guard against pathological fits by requiring the next few predicted terms (default k_extra=2) not to drop suddenly. This combination keeps the loop exact match while filtering brittle formulas that only memorise the prefix but extrapolate nonsensically.

# Verify(formula_str, seq) -> (ok, feedback_msg)
#
# Parses formula into a symbolic expression, checks exact matches for n=1..k,
# and light sanity on k+1..k+m when data are nondecreasing.

function Verify(formula_str, seq):
    # Safe parse with a restricted symbol table
    expr = try_sympify(formula_str, allowed_symbols)
    if expr == PARSE_ERROR:
        return (false, "Invalid SymPy syntax. Use n (1-indexed).")

    # Exact match on provided terms
    for i in 1..len(seq):
        got = safe_eval(expr, n=i)         # substitute n=i, then .doit() if Sum(...)
        want = exact_rational(seq[i])      # nsimplify when possible
        if not exact_equal(got, want):     # simplify(got - want) == 0 OR got.equals(want)
            table = mismatch_table(expr, seq, rows=6)
            return (false, "Mismatch at n=" + i + ".\n" + table)

    # Light extrapolation sanity if seq is nondecreasing
    if is_nondecreasing(seq):
        prev = floatify(seq[-1])
        for t in (len(seq)+1)..(len(seq)+2):
            got_t = floatify(safe_eval(expr, n=t))
            if got_t < prev - 1e-12:
                return (false, "Suspicious extrapolation drop at n=" + t)
            prev = got_t

    return (true, "Matches data and extrapolation OK")

In the final step of the loop, we feed in the output from Verify to the refinement component Refine. The Refine component is the connective tissue between Generate and Verify. It takes the checker’s targeted feedback (e.g., “Mismatch at n=4…”) and calls Generate again with include_hint=True, which adds the finite-difference degree hint (when available) plus that feedback to the prompt.

# Refine(seq, last_feedback, tried_formulas) -> (new_hint_msg)
#
# Builds a concise, targeted hint bundle: degree hint, last checker feedback,
# and small guardrails/syntax reminders.

function Refine(seq, last_feedback, tried_formulas):
    deg = finite_difference_degree(seq)    # None if not polynomial-like
    deg_hint = (deg != None) ? "Appears polynomial of degree " + deg : ""

    prior = shorten_list(sort(tried_formulas), limit=6)

    syntax_tip = "Use n (1-indexed). Examples: n*(n+1)/2, harmonic(n), Sum(1/k,(k,1,n))."

    hint = join_blocks([
        ("Degree hint", deg_hint),
        ("Checker feedback", last_feedback),
        ("Previously tried (avoid repeats)", prior),
        ("Syntax tip", syntax_tip)
    ])

    return hint

These three components — Generate, Check, Refine— are the heart of our implementation of a mini AI Mathematician, tying together an LLM with the power of a symbolic engine. Each iteration of this code proposes a newformula (tracked via tried_formulas to avoid repeats), then Verify checks it for exactness and basic extrapolation sanity. The loop stops on the first success and returns the parsed, simplified, and factored expressions; otherwise it exits after max_steps with the most informative failure reason — perfect for logging and for a higher-level controller (like your two-phase solver) to decide what to try next.

Evaluating Baby AI Gauss’ Mathematical Prowess

Baby AI Gauss was evaluated on the integer sequence benchmark introduced earlier. Its task was to discover closed-form solutions for each sequence (where such solutions exist). A natural measure of success is whether the AI can reach the correct formula within a limited number of attempts — for these experiments, I set a cap of five attempts.

Each trial is split into two phases:

• Phase A (No Hints): the AI has up to five attempts with no guidance from the symbolic engine.
• Phase B (With Feedback): if the first phase fails, a feedback loop kicks in — providing hints such as mismatch tables or degree estimates — and the AI receives another five attempts.

This setup lets us measure not only raw problem-solving ability but also the gain in performance attributable to feedback. The aggregated results across the series of GPT-x models are summarised in Table 1 below:

The results in Table 1 show a clear progression in problem-solving ability across GPT models on the integer sequence benchmark. GPT-3.5-turbo solved 55% of problems, requiring on average just over five attempts per task. GPT-4-turbo improved to 65% with a slightly lower attempt count (4.5 on average). GPT-4o-mini performed on par with GPT-3.5-turbo at 55%, while GPT-4o matched GPT-4-turbo at 65%. The leap comes with GPT-5, which achieved a perfect 100% solve rate, requiring only a single attempt on average. The math solving ability of GPT-5 appears to be a step change compared to earlier models.

Diving a little deeper into the results, Baby AI Gauss with GPT-3.5-turbo could only handle the simplest polynomial and factorial sequences, failing entirely on more advanced combinatorial or analytic families. GPT-4-turbo expanded coverage modestly, solving Catalan and Harmonic numbers and even managing a correct double factorial with hints. GPT-4o-mini and GPT-4o performed similarly, reliably solving the basics but stalling on Lucas, primes, and partition numbers. In contrast, GPT-5 solved every sequence in the set on the first attempt — not just polynomials and binomials but also recurrence-based (Fibonacci, Lucas), summation-based (Harmonic), and even the “stretch” cases of primes and partitions (via interpolation or ad-hoc encodings). This progression highlights how rapidly the newer models have moved from pattern matching toward seemingly robust symbolic reasoning.

Note on GPT-5 results.

While GPT-5 achieved a perfect score on the benchmark, this requires interpretation. For intrinsically hard sequences such as primes and partition numbers, the model produced ad-hoc formulas that interpolate the provided terms (e.g., a polynomial fit for partition numbers, or a piecewise construction for the first few primes). The checker accepted these because they reproduced the benchmark values, but they do not constitute genuine closed forms. Thus, GPT-5’s 100% solve rate reflects benchmark alignment rather than mathematical breakthroughs on unsolved problems. The breakthrough is left to DeepMind to solve 🚀

Conclusions and Final Thoughts

We imagined a near future where AI Mathematicians and Scientists are readily available in the data centre, summoned much like cloud services today. Picture an Amazon Web Services for Science: log in, choose the docker “mathematician image” you want to spin up across GPU clusters — Newton, Gauss, Riemann, Hilbert — each priced according to the computational power required. Perhaps your token budget only stretches to an “undergraduate-level mathematician,” while deeper pockets can afford the equivalent of a Gauss or Hilbert instance.

In this token economy of discovery, the cost of compute — not human genius — becomes the limiting factor. Breakthroughs of a scale never before seen could become routine, as access to scientific problem-solving is democratised and scaled. Science and mathematics may soon move from being the pursuit of a rarefied few to a global, on-demand service — radically transforming how humanity tackles its hardest problems.

Building on the results from this article, the natural next step is to scale the proposed generate–check–refine loop beyond integer sequences into richer mathematical domains. Future work could apply the same structure to proving algebraic identities, tackling symbolic integration and differential equations, and even probing open areas such as combinatorics or number theory. The integration of hints could be made more adaptive, with the AI learning when and what kind of guidance accelerates convergence. In parallel, benchmarking across diverse problem sets will help quantify progress and expose failure modes. Ultimately, this line of research points toward building modular AI mathematicians that combine LLM intuition with symbolic engines, progressively advancing from textbook problems toward research-level conjectures.

Let me end this article with this thought:

“The next Gauss may not be born — they may be spun up in the cloud.”

What was once genius — appearing only once every few centuries — may soon become a question of infrastructure and compute.

Just as Go players discovered new and richer strategies after playing against AlphaGo, mathematicians and scientists may find their horizons widened by collaborating with AI systems. Rather than replacing human ingenuity, these tools could uncover overlooked approaches, inspire novel conjectures, and expose unexpected connections across disciplines. The outcome would be a deep enrichment of the landscape of human knowledge — opening new ways of seeing, reasoning, and creating at a pace that feels both unprecedented and almost unimaginable from the vantage point of our pre-singularity world today.

Disclaimer: The views and opinions expressed in this article are solely my own and do not represent those of my employer or any affiliated organisations. The content is based on personal reflections and speculative thinking about the future of science and technology. It should not be interpreted as professional, academic, or investment advice. These forward-looking perspectives are intended to spark discussion and imagination, not to make predictions with certainty.

📚 Further Learning

• Grigori Perelman (2002) — The Entropy Formula for the Ricci Flow and its Geometric Applications — Perelman’s groundbreaking paper that laid the foundation for solving the Poincaré Conjecture.
• Richard Hamilton (1982) — Three-Manifolds with Positive Ricci Curvature — The seminal paper introducing Ricci flow, which Perelman later extended.
• Terence Tao’s Blog — Clear, modern expositions of deep mathematical insights, including coverage of Perelman’s work and geometric analysis.
• Lex Fridman Podcast #472 — Terence Tao— A deep, wide-ranging conversation with Fields Medalist Terence Tao — covering topics from fluid dynamics and number-theoretic conjectures to the evolving role of AI in mathematical discovery and proof systems
• Timothy Gowers (2000) — The Two Cultures of Mathematics — An influential essay reflecting on problem-solving and theory-building in math, relevant for thinking about how AI might participate in both cultures.
• DeepMind Blog (2024) — AI Solves IMO Problems at Silver-Medal Level. DeepMind’s AlphaProof and AlphaGeometry 2 tackled Olympiad-level math problems, achieving performance comparable to a silver medalist in the International Mathematical Olympiad.
• DeepMind Blog (2025) — Advanced Version of Gemini with DeepThink Officially Achieves Gold-Medal Standard at the International Mathematical Olympiad.