Claude Fable & The Jacobian Conjecture: A Hands-On Guide

By the end of this post you’ll have re-run the verification of a mathematical result that just disproved an 87-year-old conjecture – locally, in your terminal, in about ten lines of Python. You’ll also have a working template for the kind of prompting workflow that produced it on Claude Fable.

The news dropped over the weekend of July 19, 2026: Anthropic researcher Levent Alpöge announced on X that he and Claude Fable 5 had found a concrete counterexample to the Jacobian Conjecture – stated by Ott-Heinrich Keller in 1939 and listed as number 16 on Stephen Smale’s problems for the century. Hacker News lit up. Wikipedia was edited within hours. But most write-ups just narrate the tweet.

This post does the opposite: verify first, then reverse-engineer the workflow.

The problem with how everyone else is covering this

Every article you’ll find on the Jacobian counterexample follows the same recipe: explain the conjecture, quote the tweet, note that peer review is pending, muse about AI-and-mathematics. Fine as news, useless as a tutorial.

The gap: the counterexample is verifiable with algebra software, and Alpöge included Wolfram Alpha links in his thread. That means you don’t have to trust anybody – the tweet, Anthropic’s PR, or me. You can hand the polynomial to SymPy and check it in one sitting. And once you’ve done that, the more interesting question becomes: what prompting setup lets a working mathematician get this out of a model on a Sunday evening?

What Fable actually produced

A polynomial function from ℂ³ to ℂ³. Writing u = 1 + xy for readability, the three output coordinates are:

F(x, y, z) = (
 u^3 * z + y^2 * u * (4 + 3xy),
 y + 3x * u^2 * z + 3x * y^2 * (4 + 3xy),
 2x - 3 * x^2 * y - x^3 * z
)

Total degrees: (7, 6, 4). Two facts settle everything. The Jacobian determinant equals -2, a nonzero constant – that’s the hypothesis the conjecture rests on (per Jared Duker Lichtman’s thread at jacobianfun.org). And three distinct input points – (0, 0, -1/4), (1, -3/2, 13/2), and (-1, 3/2, 13/2) – all land on the same output (-1/4, 0, 0). An invertible function cannot send multiple inputs to the same output. Conjecture, disproved.

The reason this is such a big deal isn’t just the age of the problem. Some researchers discussing the result on Hacker News estimated the minimum-degree bound for any counterexample was near 200 – and recent arXiv work (2204.14178) painstakingly discarded two-dimensional candidates up to degree 108 and 125. Fable found one in degree 7, in three dimensions. Humans were looking in the wrong place entirely.

Verify it yourself in 10 lines

Install SymPy if you don’t have it (pip install sympy). Then paste this into a file called verify.py:

from sympy import symbols, Matrix, simplify, Rational

x, y, z = symbols('x y z')
u = 1 + x*y

F = Matrix([
 u**3 * z + y**2 * u * (4 + 3*x*y),
 y + 3*x * u**2 * z + 3*x * y**2 * (4 + 3*x*y),
 2*x - 3 * x**2 * y - x**3 * z,
])

J = F.jacobian([x, y, z])
print("det(J) =", simplify(J.det()))

pts = [(0, 0, Rational(-1, 4)),
 (1, Rational(-3, 2), Rational(13, 2)),
 (-1, Rational(3, 2), Rational(13, 2))]

for p in pts:
 print(p, "->", tuple(simplify(f.subs(dict(zip((x, y, z), p)))) for f in F))

Run it. You should see det(J) = -2, and then three lines showing all three input points collapsing to (-1/4, 0, 0). That’s the whole disproof. Indiana University’s Zihan Zhang published a near-identical script that extends the same construction to every dimension n ≥ 3 – worth reading if you want to see how far the result generalises (link via Zhang’s site).

A note worth keeping: When an AI produces a result you can verify computationally, verify it before you form an opinion about it. This one takes 30 seconds. Most “AI did science” claims can’t be checked at all – that’s usually a bigger red flag than the claim itself.

The prompting shift that made Fable useful here

You probably don’t have an open conjecture lying around. But the workflow that produced this result generalises – and it’s not the workflow most people are still using with Claude.

Anthropic’s official Prompting Claude Fable 5 guide says it plainly: skills developed for prior models are often too prescriptive for Fable 5 and can degrade output quality. Translated: the checklist-heavy, step-by-step prompts that worked on Opus 4.8 actively hurt Fable. It plans better than your scaffolding does.

Here’s what actually works on Fable, distilled from Anthropic’s guidance and field reports from the model’s first weeks:

State the goal, not the steps. Describe the end state and constraints. Fable will find the path – over-specified instructions box it in. Long documents and prior attempts belong at the top, wrapped in simple XML tags like <prior_work>...</prior_work> so the model can index them without you managing the order.

Turn effort up on hard, verifiable problems. Fable exposes an effort dial. On tasks where the answer is checkable (like a polynomial identity), max effort buys re-verification and self-correction – not just longer output. Ask for a concrete artifact, not an explanation: “Give me a specific polynomial” beats “tell me about counterexamples.” A map you can plug into SymPy is worth more than a paragraph of hedged reasoning.

One gotcha: Fable ships with summarized-only thinking output and no extended thinking budgets (confirmed in Anthropic’s Prompting Fable 5 docs, as of July 2026). Asking it to “show its chain of thought” no longer does what it used to. Delete that from your templates.

Applied to the Jacobian case: hand the model the conjecture, prior known constraints from the literature, and a request for a concrete map in the smallest dimension you can think of. Check the output yourself. That’s roughly what happened.

Where this gets awkward: cost and access

Reality check before you fire up a Fable session of your own.

Sources: Anthropic’s Fable page and the July 20 pricing announcement. Three gotchas that don’t get enough attention:

• The $100 Pro credit disappears fast. At $50 per million output tokens, generating 128K max output twice burns ~$13. One long research session with a big context loaded can finish that credit before you’ve iterated past the first promising candidate.
• Temperature is gone. No temperature parameter, no extended-thinking token budget. Copy old scaffolding that sets temperature=0.7 and it silently fails. This tripped up teams migrating from Opus – worth auditing your wrappers before you benchmark anything.
• Silent reroutes exist for biology and cybersecurity queries. Per Anthropic’s safeguards documentation, many requests in those domains get automatically handled by Opus 4.8 instead of Fable. You won’t be charged Fable prices – but if you’re running an eval that assumes you’re testing the top-tier model, you may not be.

What this actually means for you

Not that Fable will solve your open problem this weekend. The Jacobian result was produced by a Princeton-trained number theorist who works at Anthropic, using domain knowledge to frame the search. The model didn’t invent algebraic geometry. It generated a candidate that the human knew how to check.

Think of it this way: Fable is very good at the hard half of certain problems – the “generate a specific thing that satisfies these constraints” half – when the easy half (checking whether it’s correct) already exists. That’s a narrow but genuinely useful wedge. If you have a problem fitting that shape – a counterexample, a bug repro, an edge-case input, a legal clause that needs to survive a specific challenge – it’s worth pointing Fable at it.

Anthropic hasn’t confirmed a formal restoration timeline for every plan tier’s Fable access, and the counterexample itself is still awaiting arXiv posting and peer review (as of July 20, 2026). Both stories are moving weekly.

FAQ

Is the Jacobian Conjecture officially disproved now?

Not yet in the formal record – no peer-reviewed arXiv paper as of July 20, 2026. But the counterexample is computationally checkable by anyone. Run the SymPy script above and you’ll see for yourself in under a minute.

Can I reproduce this with a cheaper Claude model like Sonnet 5 or Opus 4.8?

Probably not the Jacobian result specifically. It required the reasoning depth Fable’s higher tier provides, plus a mathematician steering the search – that combination matters. For other verify-a-candidate workflows in general, though, Opus 4.8 at half the price is often good enough. A practical split: Fable for the hard “generate the candidate” step, Opus or Sonnet for verification and write-up around it. Run the expensive model only where you actually need it.

What if I try to use Fable for biology or security research?

Here’s the thing most benchmarkers miss: your request may get routed to Opus 4.8 without any visible indication. Anthropic’s safeguards documentation confirms this for biology and cybersecurity domains specifically. You won’t be billed Fable prices for the rerouted request, but you also won’t see Fable’s output – so if you’re comparing model tiers, you need to verify which model actually answered. Check the response metadata, not just the content.

Next step: save the SymPy script above, run it, and confirm you get det(J) = -2 and three collapsing points. Then pick one problem from your own work where a candidate answer is easy to verify but hard to generate. That’s the one to throw at Fable this week.