Terence Tao Using LLMs to Probe the Jacobian Conjecture
Most people use LLMs as an oracle. They ask for a snippet of Python or a summary of a meeting, and they hope the model doesn't hallucinate the answer. But Timothy Gowers, a Fields Medalist, decided to treat ChatGPT as a high-speed sounding board instead. He didn't ask it for the answer to a century-old problem in algebraic geometry. He used it to probe the edges of the problem, throwing ideas at the wall to see what stuck.
It's a subtle shift in workflow, but it's the only way these tools actually become useful for high-level intellectual work. If you treat an AI like a search engine, you're just waiting for it to fail. If you treat it like a collaborator that's read everything but understands nothing, you can move through a conceptual space much faster than you could alone.
I've seen a lot of hype about AI "solving" science, which is mostly nonsense. AI isn't going to wake up and prove a theorem on its own. But Gowers' approach shows that the real value isn't in the output, it's in the friction of the conversation.
The question is whether this method actually scales to other fields, or if it only works when you're already one of the smartest people in the room.
The Jacobian Conjecture
The Jacobian Conjecture is a problem about whether a polynomial map with a constant non-zero determinant is invertible. In plain English: if you have a set of polynomials that describe a transformation, and the "local" stretching (the Jacobian matrix) is constant and doesn't collapse to zero, does that mean the whole transformation can be undone? It sounds simple, but it's been open since 1939.
The difficulty is that local invertibility doesn't usually guarantee global invertibility. For most functions, you can have a derivative that looks fine everywhere, but the function still loops back on itself or misses parts of the space. The conjecture claims that for polynomials, this doesn't happen. This part is genuinely confusing because our intuition from calculus tells us that "locally invertible" isn't enough, yet for this specific class of functions, it might be.
If you want to test this with a simple example, you can use SymPy to calculate the Jacobian of a map.
from sympy import symbols, Matrix, diff
x, y = symbols('x y')
f = Matrix([x + y**2, y])
jacobian = Matrix([[diff(f[0], x), diff(f[0], y)],
[diff(f[1], x), diff(f[1], y)]])
print(jacobian.det()) The conjecture is essentially a gamble on the rigidity of polynomials. Most attempts to prove it fail because they can't handle the way degrees grow when you try to find the inverse. It's a frustrating gap in our understanding of basic algebra.
The Search for a Counterexample
The AI's approach to finding a counterexample is where the logic actually gets interesting. It didn't just guess; it attempted to construct a specific mathematical edge case by isolating the variables that usually cause the proof to fail. For a few steps, the reasoning is sound. It identifies the correct constraints and applies them logically. Then, it hits a wall. It starts hallucinating a property of the set that doesn't exist, and the whole proof collapses into a circular argument.
This part is genuinely confusing because the AI sounds confident right up until the moment it's wrong. It's a reminder that these models aren't doing math in the way we do; they're predicting the next most likely token in a mathematical sequence. However, there's a weird utility here. Even if the final proof is a hallucination, the "direction" it suggests—the specific way it tried to break the logic—is often a valid path for a human mathematician to explore.
If you're trying to replicate this kind of stress-testing with a model, you can't just ask it for a counterexample. You have to force it to document its constraints first.
prompt = """
1. List the axioms of the theorem.
2. Identify the weakest constraint in the proof.
3. Propose a counterexample that violates only that constraint.
"""
print(f"Sending request to LLM with constraints: {prompt}")The process is frustrating because you spend half your time debugging the AI's logic instead of the actual problem. It's a strange trade-off: you get a potential lead in exchange for an hour of cleaning up mathematical nonsense.
The Prompting Strategy
The debate over whether this is a leap or a step is mostly a distraction. Whether the underlying discovery is "revolutionary" doesn't change the immediate utility: we now have a tool that can function as a high-level technical peer for people who already operate at the ceiling of human mathematical ability. That's a specific, narrow win. For the average developer or researcher, this doesn't suddenly make them a world-class mathematician, but it does suggest that the ceiling for LLM reasoning is higher than we thought a few months ago.
I think the community is underestimating the friction of verification. It's one thing for an LLM to suggest a path to a proof; it's another for a human to spend three days verifying that the path isn't a sophisticated hallucination. The "colleague" metaphor only works if the person using the tool is skilled enough to spot a subtle error in a complex derivation. If you can't verify the output, the tool is a liability, not a partner.
The real question is whether this strategy scales to fields where we don't have a formal verification system—like software architecture or systems design—where "correctness" is often a matter of trade-offs rather than a mathematical proof.
LLMs as Mathematical Rubber Ducks
The community is currently split on whether this is a fundamental shift in discovery or just a very sophisticated autocomplete for proofs. I lean toward the latter. While it's impressive to see an LLM act as a high-level colleague to mathematicians, "colleague" is a loose term here. The model isn't intuiting new mathematical truths; it's navigating a latent space of existing logic and suggesting paths that a human then has to validate.
This matters for the speed of verification, but not for the act of original synthesis. If the AI can spot a gap in a proof or suggest a lemma that simplifies a problem, it removes the cognitive drudgery of the "rubber ducking" process. But the friction remains in the verification. A mathematician still has to spend hours, or days, ensuring the AI didn't just hallucinate a plausible-looking step that collapses under actual scrutiny.
I suspect we're overestimating how much this changes the actual output of mathematics. Having a faster way to bounce ideas around doesn't necessarily mean we'll solve the Riemann Hypothesis tomorrow. The real question is whether we'll start trusting these "suggestions" without rigorous checking, and what happens to the discipline when the path to a solution is suggested by a black box.
Conclusion
Terence Tao isn't using LLMs to solve the Jacobian Conjecture—he's using them to fail faster. The strategy of treating the model as a mathematical rubber duck to hunt for counterexamples is practical, but it doesn't change the fact that these models still hallucinate basic algebra.
I'm still not sure if this is a genuine shift in how we do high-level math or just a high-end version of using a calculator to check arithmetic. We have a Fields Medalist probing a decades-old problem with a probabilistic text generator. Whether that actually leads to a proof or just a more efficient way to hit a dead end remains to be seen.