Claude Fable’s Polynomial Mapping and the Jacobian Conjecture
Most of us have accepted that LLMs are essentially fancy autocomplete engines. They're great for boilerplate and decent at summarizing, but we don't expect them to actually solve math. Then a model spits out a specific polynomial mapping that seems to challenge one of the oldest open problems in algebraic geometry, and suddenly the "stochastic parrot" argument feels a bit thin.
I spent the last few hours digging through the Wolfram Alpha logs. The model didn't just guess. It produced a Jacobian determinant and evaluated it at two specific points that actually hold up. It's a weirdly precise result for a system that usually struggles with basic arithmetic.
I'm not ready to say we've replaced mathematicians. But when a model produces a result that makes specialists stop and stare, we have to ask if it's just mimicking patterns or if it's actually stumbled onto a shortcut we've missed for decades.
The Jacobian Conjecture explained
The Jacobian conjecture is about whether a polynomial map is invertible. Specifically, if you have a map from $\mathbb{C}^n$ to $\mathbb{C}^n$ and its Jacobian determinant is a non-zero constant, the conjecture says the map must have a polynomial inverse. It's a problem that looks simple on the surface but has remained unsolved since 1939.
The gap here is the difference between local and global invertibility. If the Jacobian determinant is non-zero at a specific point, the Inverse Function Theorem tells us the map is invertible in a tiny neighborhood around that point. That's local invertibility. The conjecture asks if that local property, when true everywhere across the entire space, forces the map to be globally invertible. This is genuinely confusing because in most other areas of calculus, local invertibility doesn't guarantee a global inverse. For example, the map $f(z) = e^z$ has a non-zero derivative everywhere, but it's not globally invertible because it's periodic. The conjecture only applies to polynomials, which are much more rigid than exponential functions.
You can check the Jacobian determinant of a system using SymPy. If the result is a constant (like -2), the conjecture suggests the system is invertible.
from sympy import symbols, Jacobian, Matrix
x, y = symbols('x y')
f = Matrix([x + y**2, y])
jac = Jacobian(f, (x, y))
det = jac.det()
print(f"Jacobian Determinant: {det}") # Output: 1The math gets messy when you move to higher dimensions. While the conjecture is trivial for $n=1$, the complexity grows as $n$ increases. Most attempts to prove it involve trying to bound the degree of the potential inverse polynomial, but those bounds often explode.
Verifying the result
To prove the mapping isn't globally invertible, you have to show that the Jacobian determinant is a non-zero constant while the function itself fails to be injective. In this specific case, the Jacobian determinant is -2. This is the core of the problem: the local condition for invertibility is met everywhere, but the global property isn't.
This part is genuinely confusing because our intuition about local derivatives usually suggests that if a function is "well-behaved" everywhere, it should be invertible. Symbolic computation breaks this intuition by allowing us to test a massive number of candidate polynomials without manual algebraic errors. Using a library like SymPy, you can define the mapping and compute the determinant of the Jacobian matrix to verify it's constant.
from sympy import symbols, Jacobian, Matrix
x, y = symbols('x y')
f = Matrix([x**2 - y**2, 2*x*y]) # Example polynomial mapping
j = Jacobian(f, (x, y))
det_j = j.det()
print(f"Jacobian determinant: {det_j}") Verification isn't just about the determinant, though. You need to find two distinct points that map to the same output. If $f(a, b) = f(c, d)$, the mapping is not injective. Once you have those points, the proof is done. It's a mechanical process of elimination that turns a theoretical conjecture into a concrete counterexample.
The counterexample mapping
The attempt to use LLMs for counterexample mapping—specifically targeting open problems like the Jacobian conjecture—is a gamble on whether these models can actually "reason" through a search space or if they're just reciting a very sophisticated library of failed attempts. I suspect the current excitement on Hacker News overestimates how much a model like Codex can contribute to formal mathematics. Finding a counterexample isn't just about generating a lot of candidates; it's about the precision of the constraints. If the model is just hallucinating plausible-looking polynomials, it's not doing math, it's doing autocomplete.
That said, there is a real utility here if we stop treating the LLM as the solver and start treating it as a bridge to formal verification tools. I think the value lies in using the model to suggest the structure of a potential counterexample, which a human then feeds into Lean or Coq. The friction is that LLMs struggle with the rigid syntax required by those provers. We're currently in a gap where the model is too loose for the prover and the prover is too rigid for the model.
The real question is whether we can actually automate the discovery of a "needle in a haystack" problem when the model's training data is essentially a map of where everyone else has already looked and failed. If the answer to the Jacobian conjecture requires a leap of intuition that hasn't been written down in a LaTeX paper yet, can a transformer actually find it?
LLMs in formal mathematics
The push to use LLMs for things like the Jacobian conjecture or Erdős's open problems is an interesting stress test, but I think the current excitement misses the gap between "suggesting a path" and "proving a theorem." LLMs are great at navigating the existing literature and suggesting a combination of techniques that a human might have overlooked. But formal math isn't about suggestions; it's about an unbroken chain of logical necessity. A model can hallucinate a single step in a proof, and the entire structure collapses.
I've seen the Hacker News threads arguing that we're close to a breakthrough here, but I disagree. Using Codex to generate Lean or Coq code is a different game than writing a math paper. The feedback loop is tighter because the compiler tells you exactly where you messed up. That's where the actual value is—not in the LLM "solving" the problem, but in the LLM acting as a high-speed draft generator for a formal verifier.
The real friction is that most interesting math isn't yet formalized. We are essentially asking models to bridge the gap between natural language intuition and rigid formal logic. I suspect we'll see a lot of "solved" problems that were actually just rediscovered through brute-force iteration of formal proofs.
The question I'm still chewing on is whether the ability to automate the verification of a proof actually helps us discover the intuition required to start one.
Conclusion
Claude Fable producing a mapping where the Jacobian determinant is -2 is a neat trick, but let's be real: this isn't a formal proof. It's a set of coordinates that look right in Wolfram Alpha. The fact that we're relying on a "math fairy" and a few tweets to vet algebraic geometry suggests we're still in the "guessing and checking" phase of LLM mathematics.
I'm not sure if this is a genuine lead or just a very sophisticated hallucination that happened to land on a plausible-looking counterexample. Until someone spends a few days manually verifying the mapping, it's just a curiosity. Does the model actually understand the constraints of the Jacobian Conjecture, or did it just get lucky with a polynomial string?