⏱️ Lectura: 11 min
A mathematical conjecture from 1939 still hasn’t fallen, not even with a chatbot helping look for an angle. In July 2026, a public ChatGPT thread circulated where someone explored, step by step, a possible counterexample to the Jacobian conjecture: one of algebra’s longest-standing open problems, included in Steve Smale’s list of mathematical challenges for the 21st century.
📑 En este artículo
The outcome of the thread doesn’t change the status of the problem: there is no validated counterexample. But it’s a perfect excuse to understand what this conjecture states, why it matters to anyone working with computational algebra or polynomial-based cryptography, and how you can test polynomial maps yourself with a handful of lines of Python.
TL;DR
- The Jacobian conjecture, proposed by Ott-Heinrich Keller in 1939, remains neither proven nor disproven in 2026.
- It states that a polynomial map from C^n to C^n with a constant, nonzero Jacobian is invertible with a polynomial inverse.
- Steve Smale included it in 1998 as problem number 16 on his list of 18 challenges for the 21st century.
- Wang proved in 1980 that the conjecture holds for every degree-2 polynomial map, in any dimension.
- Bass, Connell, and Wright (1982), along with Yagzhev (1980), reduced the general case to homogeneous cubic maps.
- A public ChatGPT thread about a possible counterexample circulated in July 2026 and reopened the debate.
- With the SymPy library in Python you can check in minutes whether a polynomial map satisfies the Jacobian condition.
- No counterexample proposed to date has survived rigorous formal verification.
What happened
The thread that reignited the conversation isn’t a paper or a preprint: it’s a public ChatGPT session where someone iteratively built candidate polynomial maps and asked the model to compute Jacobian determinants and evaluate whether any map broke the conjecture. This is exactly the kind of use that became common in 2026: a chatbot as a pocket symbolic calculator for exploring algebraic structures before sitting down to prove something rigorously.
What matters, and what’s worth clarifying upfront, is that no result from that kind of exploration counts as mathematical proof. A language model can make subtle algebra errors, and the Jacobian conjecture has a long history of proof and counterexample attempts that turned out, after review, to be wrong. The correct way to read this episode is as a demonstration of how AI is used today to explore mathematics, not as news that the problem has been solved.
Background and history of the Jacobian conjecture
German mathematician Ott-Heinrich Keller proposed the problem in 1939, asking whether certain polynomial maps with Jacobian determinant equal to 1 had a polynomial inverse. The modern formulation is more general: given a map F: C^n → C^n whose components are polynomials, if the determinant of F’s Jacobian matrix is a nonzero constant at every point, then F should be invertible and its inverse should, again, be a polynomial map.
In 1998, Steve Smale published his famous list of 18 mathematical problems for the 21st century, inspired by Hilbert’s problems from 1900. The Jacobian conjecture holds spot number 16 on that list, alongside questions about the Riemann hypothesis and the limits of computational complexity.
Since 1939 there have been dozens of proof attempts, several published in serious journals, that were later refuted due to algebra errors. That history of false positives is exactly why any informal announcement, including the one that circulated as a ChatGPT conversation, deserves skepticism: the problem has a reputation for swallowing apparently solid proofs.
Technical details: what’s proven and what remains open
Not everything is uncertain. There are solid partial results that bound the problem. Wang proved in 1980 that the conjecture holds when the degree of the polynomial map is less than or equal to 2, regardless of dimension n. For maps of degree 3 and higher, the problem remains open in the general case.
A key breakthrough was reducing the full problem to the case of homogeneous cubic maps: Yagzhev in 1980, and independently Bass, Connell, and Wright in 1982, proved that if the conjecture holds for every map of the form F(x) = x - H(x), where H is a homogeneous degree-3 map, then it holds for any degree and dimension. This doesn’t solve the problem, but it concentrates all the difficulty into a much more manageable family of maps.
| Case | Status | Who and when | Limitation |
|---|---|---|---|
| Degree ≤ 2, any dimension | Proven | Wang, 1980 | Doesn’t cover higher degrees |
| Degree ≤ 100 in two variables | Verified computationally | Moh, 1980s | Only applies when n = 2 |
| Reduction to homogeneous cubic maps | Proven | Yagzhev (1980), Bass-Connell-Wright (1982) | Simplifies the problem, doesn’t solve it |
| General case, arbitrary degree, n ≥ 2 | Open | Unsolved since 1939 | No known method covers all cases |
There’s a nuance that’s often confused and worth clarifying, since it also came up in the ChatGPT thread: there’s a real version of the problem (maps from R^n to R^n instead of C^n to C^n), and there a known counterexample does exist. Mathematician Sergey Pinchuk constructed in 1994 a real two-variable polynomial map with positive Jacobian everywhere but that isn’t globally invertible, disproving the real version of the conjecture. However, that construction says nothing about the complex version, which is what’s actually known as the Jacobian conjecture and which remains open: the properties of polynomials over R and over C aren’t interchangeable.
flowchart TD
A["General polynomial map"] --> B["Bass, Connell, and Wright reduction (1982)"]
B --> C["Equivalent homogeneous cubic map"]
C --> D{"Is the Jacobian determinant constant?"}
D -->|"Yes"| E["Look for a polynomial inverse"]
D -->|"No"| F["The conjecture doesn't apply"]
📌 Note: Pinchuk’s counterexample is real (R^2), not complex (C^2). These are distinct conjectures: confusing them is the most common mistake when reading about this topic.
How to test it yourself
You don’t need to be an algebraic geometry specialist to experiment with the Jacobian condition. Python and the SymPy library, which does exact symbolic algebra, are enough.
Installation on Windows (PowerShell):
py -m venv venv
venv\Scripts\Activate.ps1
pip install sympyInstallation on macOS:
python3 -m venv venv
source venv/bin/activate
pip install sympyInstallation on Linux:
python3 -m venv venv
source venv/bin/activate
pip install sympyWith the environment ready, this script builds the simplest polynomial map that satisfies the Jacobian condition (a triangular one, with an obvious inverse) and checks the determinant:
import sympy as sp
x, y = sp.symbols('x y')
F = sp.Matrix([x + y**2, y])
J = F.jacobian([x, y])
det_J = sp.simplify(J.det())
print("Jacobian:", J.tolist())
print("Determinant:", det_J)
print("Constant and nonzero:", det_J.is_constant() and det_J != 0)This map gives determinant 1 at every point, and indeed has a polynomial inverse: (x - y**2, y). It’s the toy example any textbook uses to illustrate the conjecture before getting into cubic maps.
To explore more interesting candidates, it helps to generate homogeneous cubic maps following the Bass-Connell-Wright reduction and check in batch whether any of them keeps the determinant constant:
import sympy as sp
import itertools
def is_valid_candidate(components, variables):
F = sp.Matrix(components)
J = F.jacobian(variables)
det_J = sp.simplify(J.det())
return det_J.is_constant() and det_J != 0
x1, x2, x3 = sp.symbols('x1 x2 x3')
variables = [x1, x2, x3]
# Example of a Druzkowski-type candidate map: x - (A*x)^3 component-wise
candidate = [x1 - x3**3, x2 - x1**3, x3 - x2**3]
print("Is valid candidate:", is_valid_candidate(candidate, variables))Running variations of this pattern, changing the coefficients and the linear combinations inside the cube, is exactly the kind of brute-force search used to computationally verify the two-variable case up to degree 100. It’s also, essentially, what an AI chat can help generate faster: variations of the pattern to test, not the proof itself.
Impact and analysis
The Jacobian conjecture isn’t just an academic curiosity. Invertible polynomial maps with a polynomial inverse (called polynomial automorphisms) show up in algebraic geometry, dynamical systems theory, and proposals for multivariate polynomial-based cryptography, where the difficulty of inverting certain maps is precisely what’s exploited as a hard problem.
The ChatGPT thread episode is interesting less for the mathematical result (which didn’t change) and more for what it reveals about the current role of LLMs in exploratory research: they’re useful for generating candidates, automating tedious algebra calculations, and quickly ruling out ideas that don’t work. What they don’t do, yet, is replace formal verification.
⚠️ Watch out: an LLM can incorrectly simplify a complex algebraic expression and present the error with total confidence. Any Jacobian calculation generated by AI needs to be re-verified with a deterministic symbolic tool like SymPy or Mathematica before taking it seriously.
The honest limitation here is twofold. First, the space of candidate homogeneous cubic maps grows very fast with dimension, so brute-force search (AI-assisted or not) has a practical ceiling: it covers small cases, it doesn’t prove the general case. Second, even if a map ever appears that seemingly satisfies the Jacobian condition and has no obvious inverse, rigorously proving non-invertibility is a problem in itself, not something solved by running a piece of code.
What’s next
Nothing suggests the Jacobian conjecture is close to being solved in the short term: it’s been open for 87 years and has survived attempts by professional mathematicians with far more resources than a chat thread. What is predictable is that this kind of AI-assisted exploration will keep multiplying, since it drastically lowers the cost of generating and ruling out candidates.
For the computational algebra community, the real point of interest isn’t whether a chatbot will solve the problem, but whether these tools help human researchers cover more search ground before investing weeks in a formal proof attempt.
📖 Summary on Telegram: View summary
Try it yourself: install SymPy with pip install sympy and run the Jacobian check on your own polynomial map in under five minutes.
Frequently Asked Questions
What is the Jacobian conjecture in simple terms?
It’s the claim that if you transform variables using polynomials and that transformation doesn’t “collapse” the space at any point (constant, nonzero Jacobian determinant), then the transformation can be undone using polynomials as well.
Why is it so hard to prove?
Because even though the statement sounds simple, the reduction to the homogeneous cubic case still leaves a space of possible maps too large to analyze case by case, and there’s still no general technique that covers all dimensions and degrees at once.
Is there a known counterexample?
Yes, but for the real version of the problem (maps from R^2 to R^2), constructed by Pinchuk in 1994. The complex version, which is the actual Jacobian conjecture, still has no counterexample or proof.
Is AI useful for solving this kind of problem?
It’s useful as a computation assistant and for exploring candidates faster, but any result needs independent symbolic verification. There is no validated case of an LLM proving or disproving the conjecture on its own.
What practical applications does this conjecture have?
It touches algebraic geometry, polynomial dynamical systems, and some cryptographic schemes based on the difficulty of inverting multivariate polynomial maps.
Where can I follow the discussion or try my own analysis?
The original ChatGPT thread that reignited the topic is linked in the references, and with SymPy you can replicate and extend the checks described in this article.
References
- ChatGPT conversation: the public thread that explored a possible counterexample and reignited the discussion in July 2026.
- Jacobian conjecture, Wikipedia: a summary of the statement, history, and proven partial results.
- Smale’s problems, Wikipedia: the list of 18 mathematical problems for the 21st century published by Steve Smale in 1998.
- SymPy: the Python symbolic algebra library used in this article’s code examples.
📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion
0 Comments