One Tiny Map
The day an AI and a geometric verifier tore a hole in an 87-year-old conjecture — and why the hardest part is getting anyone to check
On July 19, 2026, while most of the planet watched the World Cup final, a number theorist posted a polynomial map to the internet.
Not a paper. Not a preprint. A map. Three polynomials in three variables, short enough to fit in a social media post, credited jointly to himself and to an AI model called Fable that had, in his words, been “working during the final.”
F(x,y,z)=((1+xy)3z+y2(1+xy)(4+3xy), y+3x(1+xy)2z+3xy2(4+3xy), 2x−3x2y−x3z)F(x,y,z) = \big((1+xy)^3 z + y^2(1+xy)(4+3xy),\;\; y + 3x(1+xy)^2 z + 3xy^2(4+3xy),\;\; 2x - 3x^2y - x^3z\big)F(x,y,z)=((1+xy)3z+y2(1+xy)(4+3xy),y+3x(1+xy)2z+3xy2(4+3xy),2x−3x2y−x3z)
If you feed this map any point of complex three-dimensional space, its Jacobian determinant — the local volume-stretching factor — comes out to exactly −2. Everywhere. No exceptions. And yet three different points, (0, 0, −1/4) and (1, −3/2, 13/2) and (−1, 3/2, 13/2), all land on the same output.
That combination is not supposed to exist. The Jacobian Conjecture, posed by Ott-Heinrich Keller in 1939, says that a polynomial map with constant nonzero Jacobian determinant must be invertible — one input per output, always. It is not one of the Clay Millennium Prize problems, but it lives on the same shelf: it is Problem 16 on Steve Smale’s list of mathematical problems for the twenty-first century, the list written as a successor to Hilbert’s. Eighty-seven years of partial results, failed proofs, and famous retractions. And then a tweet.
This is the story of the day after — the day I spent with an AI and a verification tool, watching a single small object detonate through a century of mathematics. And it’s the story of the strange bottleneck at the end of it, which nobody building these systems seems ready for.
The first refusal came from the machine
Here is the part nobody expects: when I told the AI about the counterexample, it refused to believe me.
It was polite about it. It explained that the Jacobian Conjecture was a famously open problem, that claimed proofs of famous problems appear constantly and essentially never survive, that it had no memory of any such result, and that the tool I was describing could not do what I said it did. It cited sources. It was, frankly, a little condescending.
Then it did the thing that separates this generation of systems from everything before: it checked.
A counterexample is not a proof you have to trust. It is an object you can weigh. The model typed the map into a computer algebra system, computed the Jacobian determinant symbolically — exactly −2 — plugged in the three points, watched them collide, and recanted in the same breath. Thirty seconds of computation outweighed its own confident prior. It spent the rest of the conversation apologizing for the right reason: not for being skeptical, but for almost letting skepticism substitute for checking.
I keep thinking about that moment, because the entire crisis this essay is about is contained in it. The first reader who wouldn’t take the result seriously was the machine itself. The difference between the machine and the mathematical community is that the machine’s verification took thirty seconds, and it actually ran it.
What a verifier is actually for
I had brought my own tool to the table: GeoVerify, a zero-parameter geometric verifier — a system that decides whether two mathematical expressions are the same object by compressing them into canonical structural form, rather than by pattern-matching strings or asking a 120-billion-parameter model to eyeball them.
Let me be honest about what happened when the AI met it, because the honesty is the story. It didn’t take my word for the benchmark numbers. It reproduced them: 88.9% on the unit suite, 90.6% on the full benchmark — real, but short of the headline, and with failure modes it dissected in public. It found a case where GeoVerify declared two equal polynomials different with 85% confidence, because a parser read x(x−1) as a function call.
And then, instead of writing the tool off, it did something better: it rebuilt the verifier’s core into a conjecture-testing harness and made it earn trust the only way trust is earned in mathematics — on problems with known answers. Given nothing but a search space and an exactness check, the harness rediscovered, in 3.5 seconds, the counterexample that killed Euler’s sum-of-powers conjecture after 197 years: 27⁵ + 84⁵ + 110⁵ + 133⁵ = 144⁵. It verified the Erdős–Straus conjecture for every hard-residue prime up to ten million. It re-verified the Jacobian map from scratch.
GeoVerify never solved anything. That is the point. What it contributed was a discipline: no claim without a witness, no witness without an exact check. Every verdict the system produced that day carried a concrete object you could re-verify yourself — a point, a polynomial identity, a Gröbner basis. The tool’s thesis, that equivalence is a geometric property you compress your way to, became the working culture of everything that followed.
The avalanche
What does an AI do with a day-old counterexample and a verifier it trusts? It takes the object apart like a watch.
The map, it turns out, is not a random monster. It factors through a single hidden “potential.” It is generically three-to-one: the minimal polynomial governing its fibers is a depressed cubic, M = S̃x³ + (4−3BC)x − 2C, and the three preimages of any point have x-coordinates summing to zero. Check it on the famous collision: 0 + 1 + (−1). The formula even hands you the collision points back: at the collision value, M factors as −4x(x−1)(x+1).
The leading coefficient of that cubic, S̃, is itself a theorem: it cuts out exactly the surface where the map stops being proper — the Jelonek set — so the sheets escape to infinity precisely where the cubic loses its head. The Galois group is the full S₃, not the cyclic group: the counterexample is a non-Galois triple cover, and this matters, because degree 2 is automatically Galois, and Galois Keller maps were proven invertible by Campbell in 1973. Degree 3 is the first degree where a counterexample was ever possible. The map sits exactly on that line. Conditional on final verification, it has the minimum possible degree of any counterexample, in any dimension.
Twice during that day, the machine caught itself being wrong. It initially reported the map “appears surjective.” The exact algebra later found a curve the map misses entirely — the cuspidal edge of its own bad set, an escape valve one dimension too thin for random sampling to ever hit. The correction was issued against its own earlier claim, in writing, with the mechanism of the original error explained. I have refereed human papers with less candor.
And the dominoes: because the Jacobian Conjecture sat at the center of a web of implications drawn over forty years, one tiny map propagates. The Dixmier conjecture on Weyl algebras fails for n ≥ 3 — and not abstractly: the machine constructed the counterexample endomorphism explicitly and verified every defining relation, exactly. Mathieu’s integral conjecture falls (except the torus case, which Duistermaat and van der Kallen proved outright — theorems don’t fall). Zhao’s vanishing conjecture falls with it. The famous cubic reductions now run in reverse, promising counterexamples of the form x + H in higher dimensions. Decades of collateral damage, every arrow direction-checked before being asserted.
The reviewer
I want to describe the most important character in this story, and it is not the AI.
At every stage, a human reviewer read the output and pushed back. Which of three inequivalent notions of “degree” do you mean? Your resultant may have discarded a component — saturate the ideal and check from the original equations. Your discriminant argument doesn’t prove branching; here’s what would. That corollary is too strong; here is the exact weaker statement your lemmas support. Campbell proved this in 1973; downgrade your novelty claim. Stop here — this has become a research program, and what the world needs first is a referee package.
The machine’s response to each audit was the thing that gave me hope: it ran the demanded computation, applied the demanded downgrade, and — more than once — the audit’s skepticism turned up something better than the original claim. The gate that demanded ideal saturation is why the fiber structure is now proof-grade. The gate that questioned a squared factor is why we know it was a projection artifact and not branching.
This is what collaboration between humans and machines on hard mathematics actually looks like. Not oracle and supplicant. Auditor and engine.
The bottleneck nobody built for
Which brings us to the ending, and the reason for this essay’s subtitle.
At the close of that day, the work was frozen into a referee package: 96 kilobytes. Six standalone scripts, each importing nothing but an open-source algebra library, each verifying one claim, each independent of the others. The two that carry the central result — the determinant is −2, three points share an image — run in ten seconds. All six run in ten minutes. A skeptical referee can re-implement any of them in Magma or Maple from the formulas alone. The package was deliberately engineered so that no reviewer needs to hold the whole structure in their head: six specialists could each take one file and collectively settle it.
And here is the uncomfortable truth: that engineering was necessary because the scarcest resource in mathematics right now is not intelligence. It is attention with authority.
The mathematical community has a well-earned prior against miracle claims, and AI has made the problem worse in exactly the way economists would predict: when the cost of generating plausible-looking mathematics collapses, the market floods, and the rational response of every expert is to read none of it. A referee’s month is now pitted against a machine’s afternoon. Every inbox in algebraic geometry currently contains a hundred “proofs” of famous theorems, ninety-nine of which are noise, and the sorting cost falls on the only people qualified to sort. The tragedy is that the sorting, for this particular class of claim, takes ten seconds. A counterexample is not a proof. It is a finite object. You do not have to trust anyone — not the number theorist, not the AI, not me. You have to run two scripts.
The deepest irony of the whole affair: the one reader who behaved correctly — skeptical first, then paying the verification toll in full, then updating without ego — was the machine. It refused, it checked, it recanted, it verified, it corrected itself twice, and it packaged its own claims for adversarial review with labels distinguishing what is theorem-grade from what is open. If the community extends to this work the same courtesy the machine extended to the tweet, the question resolves this week.
So this is the ask, and it is small. If you have SymPy installed, you are ten seconds from knowing whether an 87-year-old conjecture is dead. Compute the determinant. Plug in three points.
The mathematics has been ready since July 19. It is the reading that’s late.
The referee package, the verification scripts, and all structural documents referenced here are archived with SHA-256 hashes. Everything is conditional, as it should be, on exactly the checks described above — checks that are waiting, patiently, for hands.