Claude Fable 5 and the Jacobian Conjecture: What Was Proved and What Wasn’t

On the night of the World Cup final, most people were watching football. A small corner of the internet was watching math history move.

Anthropic researcher Levent Alpöge posted a short message on X. He said the Jacobian conjecture was false. This is a problem that has stood unsolved since 1939. He credited a colleague for suggesting the problem. He credited Claude Fable 5 for doing the work during  the match.

By the next day, mathematicians had checked it by hand. It held up.

But "AI breaks 87-year-old math problem" is a headline that travels faster than the details behind it. So let's slow down. What's actually new here? What isn't? And can you check it yourself?

You can. In about fifteen lines of Python. We'll get to that.

The Quick Answer

Claude Fable 5 helped construct a polynomial map from three-dimensional complex space to itself, written ℂ³ → ℂ³. Its Jacobian determinant is the constant -2 everywhere, which is exactly the condition in Keller's 1939 conjecture, yet the map sends three different input points to the same output. That single example disproves the conjecture in dimension three and above. The original two-variable version of the problem is still open, and there's no peer-reviewed paper yet, only a verified calculation and a preprint.

That's the whole story in one paragraph. The rest of this article unpacks why each clause in it matters.

What Is the Jacobian Conjecture?

Picture a function that takes in a list of numbers and spits out a new list. This is a "map" from one space to another. Mathematicians ask a simple question about maps like this: can you always work backward? If you know the output, can you recover the exact input that made it?

If you've done any machine learning, you've already met the object at the center of this question, probably without the drama. The Jacobian is the matrix of a map's partial derivatives: the thing backpropagation multiplies together at every layer. Normalizing flows need its determinant too, to track how probability mass stretches as it moves through the network. Same matrix. Different neighborhood.

Calculus gives you a local test for reversibility built on exactly this matrix: the Jacobian determinant. If it's nonzero at a point, the map is reversible near that point.

But near a point isn't the same as everywhere. Here's the cleanest example I know, and it takes two lines:

import numpy as np

f = lambda x, y: (np.exp(x) * np.cos(y), np.exp(x) * np.sin(y))

print(f(0, 0))              # (1.0, 0.0)
print(f(0, 2 * np.pi))      # (1.0, ~0.0) — same output, different input

This map's Jacobian determinant is e^²ˣ, which is never zero. It passes the local test at every single point in the plane. It still can't be reversed, because it wraps around: two different roads, same house.

Notice, though, that this example uses an exponential. In 1939, German mathematician Ott-Heinrich Keller asked whether polynomials behave better. His question: if a polynomial map's Jacobian determinant isn't just nonzero everywhere, but one fixed constant everywhere, does that finally guarantee full, global reversibility?

For 87 years, nobody could answer that. No proof. No counterexample either. That's the conjecture Claude Fable 5 just dented.

What Claude Fable 5 Actually Found

Alpöge's post included an explicit polynomial map from ℂ³ back to itself. Its Jacobian determinant works out to a constant, -2, at every single point. That's Keller's exact condition. And yet three separate points go in, and all three come out the same.

Anyone with a computer algebra tool can plug them in and check. That's exactly what happened: mathematicians ran the numbers within hours, and the arithmetic checked out.

Because the counterexample lives in three dimensions, it also breaks the conjecture for every higher dimension. Take the 3D map, pad it with extra untouched variables, and you have a working counterexample in four dimensions, five, or a hundred. Padding only goes up, though. It can't squeeze a 3D counterexample down into two variables, which is why the final section of this article exists.

Check It Yourself in Python

This is where a story about frontier AI becomes an exercise you can run in a notebook. It's worth running. There's something clarifying about seeing the counterexample hold up in exact arithmetic on your own machine. You'll need sympy, nothing else.

First, define the map and confirm the determinant:

import sympy as sp

x, y, z = sp.symbols("x y z")

# The map Claude Fable 5 helped construct, from C^3 to C^3
f1 = (1 + x * y) ** 3 * z + y**2 * (1 + x * y) * (4 + 3 * x * y)
f2 = y + 3 * x * (1 + x * y) ** 2 * z + 3 * x * y**2 * (4 + 3 * x * y)
f3 = 2 * x - 3 * x**2 * y - x**3 * z

# Keller's condition: the Jacobian determinant must be a nonzero constant
jacobian = sp.Matrix([f1, f2, f3]).jacobian([x, y, z])
print(sp.simplify(jacobian.det()))

-2

Not "approximately -2." Exactly -2, symbolically, for every point in ℂ³. One condition down.

Now the collision. I found these three points by asking SymPy to solve F(v) = F(1, 1, 1). Alpöge's original post lists its own set, and either works:

s = sp.sqrt(53)

points = [
    (1, 1, 1),
    (sp.Rational(-1, 2) - 7 * s / 106, 25 - 3 * s, -134090 + 18420 * s),
    (sp.Rational(-1, 2) + 7 * s / 106, 25 + 3 * s, -134090 - 18420 * s),
]

for p in points:
    image = [sp.simplify(f.subs({x: p[0], y: p[1], z: p[2]}))
             for f in (f1, f2, f3)]
    print(image)

[22, 34, -2]
[22, 34, -2]
[22, 34, -2]

Three genuinely different inputs. One output. If three inputs give one answer, no inverse can exist, and Keller's conjecture is gone. You just verified, in exact arithmetic, the calculation that settled an 87-year-old problem.

If you skipped the code, here's the summary: both halves of the claim, constant determinant and colliding points, pass symbolic verification. No floating-point trust required.

Wait, Didn't Someone Already Disprove This?

Before going further, it's worth addressing something you might have encountered in the replies to Alpöge's post, because there's an older result in this area that keeps coming up and the distinction matters.

In 1994, Sergey Pinchuk found a two-variable, real-number polynomial map that was locally reversible everywhere but not globally reversible. It's a well-known construction, and it's tempting to assume Fable 5's version is just that idea stretched into a third dimension.

It isn't. Pinchuk's map only needs its Jacobian determinant to be nonzero. The value is allowed to drift from point to point, and the whole thing only works over the real numbers. That answers a weaker question, sometimes called the "strong real Jacobian conjecture." Keller's original asks for complex numbers and a fixed constant, a bar Pinchuk's construction was never built to clear. Mathematicians have known about this gap for three decades.

Why do complex numbers raise the bar? Roughly: over the reals, a polynomial can dodge trouble by simply having no real solutions at the bad spots. x² + 1 never hits zero on the real line, but over ℂ it must. Complex space leaves a map nowhere to hide, so surviving Keller's condition there is a much stronger demand. The exponential map from earlier already hinted at this, since the wrap-around that broke it is a thoroughly complex-number phenomenon.

The two results do share a family resemblance. Both exploit the gap between reversible-in-every-neighborhood and reversible-across-the-whole-space. That's a sign of how math builds on itself, not proof that nothing new happened here.

What's Still Unresolved

The two-variable case is still open. This is the original, most-studied version of the conjecture, for maps from the plane back to itself, and as noted earlier, no amount of padding brings a 3D counterexample down to it. Several mathematicians consider the plane case the harder, more central problem. It's now the surviving core of the conjecture, not a smaller version of the one just settled.

This also hasn't been through peer review. Right now it's a verified calculation and a preprint, not a refereed paper. Since the whole thing reduces to the two computations you just ran, verification probably isn't the sticking point, but the record should say what it is.

There's a deeper gap too. Nobody can fully explain why the counterexample works. A symbolic check confirms the collision is real; it doesn't hand you the story behind it, the kind of explanation a mathematician could rebuild from scratch. Akhil Mathew, the University of Chicago mathematician who suggested the problem, put it well: you can verify the answer, but it would be nicer to have a story to tell.

The discovery process itself stays a little foggy. A human posed the question, an AI did the work, a human announced the result. That credit line doesn't show the prompts, the false starts, or how much steering happened along the way. That's a real question about how AI-assisted proofs get credited, and a separate one from whether the math holds up. It does.

Final Thoughts

The math is real. A decades-open conjecture has a genuine hole in it for dimension three and up, confirmed independently with standard tools, and it isn't a rehash of Pinchuk's 1994 result. What it isn't is a full resolution of "the Jacobian conjecture." The plane case still stands, and the result arrives without the kind of explanation mathematics usually prizes as much as the answer itself.

It's also part of a pattern. Frontier models have chipped away at long-standing open problems throughout 2026, in combinatorics and number theory alike. Read this as one more data point in that trend, not a one-off.

For anyone learning to work with AI on technical problems, the lesson isn't "AI can do research math now." It's narrower: these models are getting good at producing concrete objects in domains where success has an exact verifier, and as you saw above, you can be that verifier with a pip install sympy. Generation is racing ahead. Verification is keeping pace. Understanding still has some catching up to do.

Linear algebra and symbolic Python are the two skills worth building here: determinants, invertibility, and the habit of checking claims in exact arithmetic rather than trusting them. The next time a result like this drops, you'll be ready to run the check yourself before the day is out.