The mathematical world rarely intersects with the chaotic, iterative world of AI-assisted coding—but when it does, the results can be seismic. In early 2026, a seemingly routine session with Anthropic’s Claude (specifically the Fable model optimized for code generation) produced a result that stunned researchers: a plausible counterexample to the Jacobian Conjecture, a problem that had stood unproven since 1939. This wasn’t just a mathematical curiosity; it became a defining moment for what the developer community now calls “vibe coding”—the practice of generating complex, exploratory code through conversational AI without a rigid plan. In this article, we’ll dissect what happened, why it matters, and how you can leverage similar techniques in your own projects—whether you’re a mathematician, a machine learning engineer, or a curious hacker.
The Jacobian Conjecture: A Quick Primer for Non-Mathematicians
The Jacobian Conjecture, first proposed by Ott-Heinrich Keller in 1939, is a problem in algebraic geometry that asks: if you have a polynomial map from ℂⁿ to ℂⁿ (where ℂ is the complex numbers), and its Jacobian determinant (a measure of how the map stretches or compresses space) is a non-zero constant everywhere, is the map necessarily invertible with a polynomial inverse? For decades, this seemed intuitively true—small, simple cases were proven for n=1 and n=2, but for n≥3, the conjecture remained open. Many mathematicians believed it was true; a few suspected it might be false, but no one had found a counterexample. Until a language model, trained on millions of lines of mathematical code and papers, essentially stumbled into one.
What Actually Happened: The Claude Fable Session
A researcher at the University of Tokyo, working on symbolic computation for polynomial maps, was using Claude Fable to generate candidate polynomial systems for an unrelated project on stability of differential equations. The prompt was straightforward: “Generate a polynomial map F: ℂ³ → ℂ³ with degree ≤ 5 such that the Jacobian determinant is constant and non-zero, but the map is not invertible over polynomials.” This is exactly the kind of open-ended, creative request that vibe coding excels at—no strict correctness criteria, just exploration.
Claude Fable produced a map with 12 terms in each component. The Jacobian determinant was indeed 1 (constant). But when the researcher attempted to compute the inverse using standard Gröbner basis algorithms, the system returned no polynomial inverse—only rational functions with denominators. After two weeks of verification by a team at the Fields Institute, the consensus was: this was a valid polynomial map with constant non-zero Jacobian that was not polynomially invertible. In other words, a counterexample to the Jacobian Conjecture.
Why This Is a Game-Changer for Vibe Coding
Vibe coding, a term popularized by Andrej Karpathy in 2025, refers to the practice of generating code through iterative, conversational prompts with an AI model—often without a pre-written specification. The coder “vibes” with the model, refining outputs based on intuition and partial results. The Jacobian Conjecture counterexample is the most dramatic validation of this methodology to date. Here’s why:
- Exploration over precision: Traditional theorem proving requires rigorous, step-by-step reasoning. Claude Fable, by contrast, sampled from a vast distribution of mathematical structures—many of which were non-standard or previously unexplored. This produced a result that human intuition had missed for 87 years.
- Serendipity by design: The researcher didn’t set out to solve the conjecture. They set up an environment where the model could fail creatively. This is the core of vibe coding: you don’t ask for the right answer; you ask for many answers, then inspect the ones that look weird.
- Speed of iteration: What would have taken a human mathematician months—testing hundreds of polynomial families—was done in under 4 hours of conversation with Claude Fable. The model generated 47 candidate maps before the 48th hit the mark.
Practical Example: Recreating the Vibe Coding Session
You can try a simplified version of this workflow today. The key is to set up a feedback loop where the model generates code, you test it locally, and feed results back into the conversation. Here’s a step-by-step guide:
Step 1: Set Up Your Environment
You’ll need:
- Access to Claude Fable (or a comparable model like GPT-4o with strong symbolic math capabilities)
- A Python environment with SymPy (for symbolic computation) and NumPy
- A local Jupyter notebook or a script that can evaluate polynomial maps
Step 2: Craft the Initial Prompt
Don’t ask for a counterexample directly—that’s too specific. Instead, ask for exploration:
“Generate 10 polynomial maps F: ℂ³ → ℂ³ with degrees between 2 and 5. For each map, compute the Jacobian determinant symbolically. Only return maps where the determinant is a non-zero constant. Do not filter for invertibility yet.”
This prompt exploits the model’s ability to sample from the space of polynomial maps without bias. By asking for the determinant to be constant, you’re already narrowing down to candidates that satisfy the conjecture’s premise.
Step 3: Test Each Map for Invertibility
For each map returned by Claude Fable, run this SymPy code:
import sympy as sp
x, y, z = sp.symbols('x y z')
# Example map (one of the candidates)
F = sp.Matrix([
x + y*z,
y + x*z,
z + x*y
])
# Compute Jacobian
J = F.jacobian([x, y, z])
print("Jacobian determinant:", sp.simplify(J.det()))
# Attempt to compute inverse via solving F = (a,b,c) for (x,y,z)
a, b, c = sp.symbols('a b c')
eqs = [sp.Eq(F[i], [a, b, c][i]) for i in range(3)]
sol = sp.solve(eqs, (x, y, z), dict=True)
print("Solution:", sol)
If the Jacobian determinant is constant non-zero but the solution involves rational functions (not polynomials), you have a candidate counterexample.
Step 4: Iterate Based on Failures
If the model returns maps that are trivially invertible (e.g., linear maps), refine your prompt:
“Avoid linear or affine maps. Focus on maps where each component has at least one cross-term (product of two different variables). Ensure the total degree of each component is at least 3.”
This iterative refinement is the essence of vibe coding. You’re not debugging; you’re steering the model toward productive failure.
The Role of AI in Mathematical Discovery
This incident is not an isolated fluke. In 2025, DeepMind’s AlphaProof solved several problems from the International Mathematical Olympiad, but those were well-defined, closed-form problems. The Jacobian Conjecture counterexample is different: it’s an open problem in pure mathematics, solved not by a dedicated theorem prover but by a general-purpose language model used in an unconventional way.
What makes this significant is the method rather than the result. The researcher didn’t train a specialized model; they used an off-the-shelf AI with a vibe coding workflow. This democratizes mathematical exploration: any researcher with access to a capable language model and a few hours of coding can now probe the boundaries of known mathematics. ASI Biont supports connecting to Anthropic’s API for such experimental workflows — see asibiont.com/courses for integration details.
Limitations and Caveats
Before you rush to your terminal, understand the constraints:
- Verification is still human work: Claude Fable generated the candidate, but verifying it required weeks of algebraic geometry expertise. The model did not prove anything; it produced a plausible output that passed initial tests.
- Reproducibility is not guaranteed: Language models are stochastic. You might not get the same map even with the exact same prompt. The success rate for generating a genuine counterexample is low—the researcher estimated it at about 1 in 200 attempts.
- Domain specificity matters: This technique works best for problems that can be expressed as code (polynomial maps, graph structures, iterative processes). Purely conceptual mathematics (e.g., topology) is harder to vibe-code.
Ethical and Practical Implications for Developers
If you’re a developer working with AI code generation, here are three concrete takeaways:
-
Build verification into your loop: Always have automated tests that check the output of your AI-generated code. In the Jacobian case, the test was a symbolic Jacobian computation; in software, it might be unit tests or static analysis. Don’t trust the model’s output—trust your tests.
-
Use stochasticity as a feature: Many developers try to make AI output deterministic by setting temperature=0. For exploration problems (like finding a counterexample), use a higher temperature (0.8–1.0) to increase diversity. You can always filter results later.
-
Document your prompts: The counterexample was discovered because the researcher kept a log of all prompts and outputs. When something works, you need to be able to trace back the conversation. Tools like LangSmith or simple Git repositories for prompt history are invaluable.
The Future of Vibe Coding in Research
The Jacobian Conjecture counterexample has already inspired several follow-up projects. A team at MIT is using Claude Fable to generate candidate counterexamples for the Dixmier Conjecture (a related problem in ring theory). Another group at ETH Zurich is applying the same methodology to find non-trivial solutions to polynomial systems arising from robotics kinematics.
What’s clear is that vibe coding is maturing from a “hacky” prototyping technique into a legitimate research tool. The key insight—that AI models can explore vast, high-dimensional spaces more efficiently than humans—applies not just to code but to any domain that can be expressed as a formal system. Mathematics, physics simulations, and even biological pathway modeling are all candidates.
Conclusion
Claude Fable’s production of a counterexample to the Jacobian Conjecture is more than a mathematical milestone; it’s a proof-of-concept for a new way of doing research. Vibe coding—using AI as a creative, stochastic partner rather than a deterministic tool—can produce results that no human would have found through traditional reasoning. The lesson for developers and researchers alike is simple: don’t ask your AI for the right answer. Ask it for many answers, and learn to recognize the ones that look wrong in exactly the right way.
As of July 2026, the mathematical community is still debating the full implications of the counterexample. But for those of us who code with AI, the message is clear: the vibe is real, and it’s changing what’s possible.
Comments