Data analysis and machine learning without the Jacobian.
Telling whether a transformation can be undone — using topology, set theory,
fractal scaling and chaos, instead of a derivative.
Jacobian conjecture · refuted July 2026 · arXiv:2608.00222
Imagine a machine that takes a point and moves it somewhere else. Feed it a point, it gives you back a different point. Simple.
Now the question that matters: can you always run it backwards?
If you know where a point ended up, can you work out where it started? Usually yes. But sometimes the machine takes two different starting points and drops them in the exact same place. When that happens the information is gone forever. There is no running it backwards, because the machine itself no longer remembers which of the two you began with.
That failure has a name — the map is not injective — and it breaks things people rely on every day:
- Image generators compute how likely an image is by running their transformation backwards. If it can't run backwards, the probability is wrong.
- Medical image alignment warps one brain scan onto another. If the warp folds, two bits of tissue land on top of each other and the alignment is nonsense.
- Physics simulations need their meshes not to fold through themselves.
So everybody checks. The question is how.
The standard check looks at one point at a time.
At each point you ask: right here, does the machine squash space flat? You can measure that — it's a number called the Jacobian determinant, and if it's zero the machine has crushed something out of existence at that spot. So people compute it everywhere, find it's never zero, and conclude: nothing is being crushed, so nothing is being lost, so the machine can be run backwards.
That reasoning has a hole in it, and the hole is easy to see once you look for it.
Nothing local is going wrong. Something global is.
Picture a long strip of paper. Roll it into a tube. At every single point on that paper nothing bad happens — no crushing, no tearing, no folding. Every tiny patch is perfectly fine. But the two ends of the strip now touch. Two points that started far apart are now in the same place. A check that only ever looks at one point at a time cannot see this, because at no single point is anything wrong.
For 87 years mathematicians hoped this couldn't happen in the cleanest case. That hope had a name — the Jacobian conjecture — and in July 2026 it was refuted. Somebody built a machine where the local check passes perfectly everywhere, and the machine still folds two points together.
The paper's own words for its counterexamples:
everywhere unramified, and fail to be injective only through points escaping to infinity
"Everywhere unramified" means the local check passes at every point. And the map still isn't reversible. The local check isn't weak. It's blind.
If one point can't tell you, use two.
Take two points. Measure how far apart they were before, and how far apart they are after. Divide.
distance after
--------------
distance before
If the machine folds two points together, this ratio goes to zero for that pair — they were far apart, now they're on top of each other. So find the smallest ratio over all pairs. If it's tiny, something got folded.
There's one catch: "tiny" compared to what? A machine that shrinks everything by a thousand isn't broken, it's just small. So compare the smallest ratio to the typical ratio:
smallest ratio
---------------
typical ratio
Now it's a fair comparison. A well-behaved machine's worst pair isn't much worse than its average pair. A folding machine's worst pair is catastrophically worse. That's the whole idea, and no derivative appears anywhere in it — just distances between points you already have.
from monodromy import collision_certificate
c = collision_certificate(F, sampler)
c["collision_found"] # True -> it found two points that collide
c["witness"] # ...and here they areThe witness matters. It doesn't just score the machine — it hands you the actual pair of points that broke it, so you can check for yourself.
Eight machines where the true answer is known in advance by algebra, drawn from the situations described above.
| gets it right | |
|---|---|
| the standard derivative check | 6 out of 8 |
| this library | 8 out of 8 |
The two it misses are exactly the two the 2026 refutation predicts: machines where every local check passes and two points collide anyway.
And this is not a rigged fight. The derivative check is right six times out of eight, including on the fold it was designed to catch. It fails in one specific way, and that way is now known to be real rather than hypothetical.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
eight machines, truth known in closed form
reversible 0.216 0.450 0.706 0.015
NOT reversible 0.002 0.001 0.005 0.002
────────────────────────────
the two groups are separated by a factor of 3
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
The same idea — stop looking at one point, look at the shape — turns out to
answer several other questions. Each has its own page in docs/.
| you want to know | ask for | the idea in one line |
|---|---|---|
| can this be undone? | collision_certificate |
find the two points that collide |
| can you prove it? | certify_injective_on_box |
on a box, interval arithmetic gives a real proof |
| does this shape have symmetry? | recover_dihedral |
rotate it and see if it lands on itself |
| how crinkly is this data? | ph_dimension |
measure how detail grows as you zoom in |
| is this system chaotic? | map_spectrum |
measure how fast nearby paths separate |
| where do I put my cutoff? | minimax_threshold |
the value an adversary can't exploit |
pip install -e .
pytestNeeds numpy, scipy, ripser, persim, mpmath. Not torch — it was in here once, carrying eight lines of linear algebra that numpy does natively, and it's gone.
Every library says it works. Here is what this one can't do, up front:
- It usually can't prove a machine is fine. It can prove one is broken — by handing you the colliding pair. Absence of evidence is reported as absence of evidence, not as a clean bill of health. Only the box certificate proves the positive.
- Symmetry detection is honest, not complete. On clean shapes it's perfect. Add 10% noise and it usually gives up and says "found nothing" rather than guessing. When it does name a symmetry it has never once been wrong across 24 trials on shapes with no symmetry at all.
- The crinkliness measure has a ceiling. Trust it up to about 3 dimensions. Above that it reads low, and adding data makes it worse, not better.
- One function is slow.
so3_scantakes 73 seconds on 100 points and over 5 minutes on 500. That's in its docstring now. - The cutoffs are calibrated on small samples. Fewer than thirty cases each. One of them was measured not to transfer to a different sample size, so it now refuses to run below that size rather than quietly giving you a wrong answer.
There is a whole page of things this library got wrong and fixed —
docs/corrections.md — including a result that looked
new, survived a week of excitement, and turned out to be published in 2019 with
a statistic that collapsed under re-testing.
None of the mathematics is new. It is Kingman's subadditive theorem, covering spaces, interval arithmetic, Steele's theorem and Schweinhart's estimator — all decades old, none invented here.
The narrower question is whether anyone has pointed them at this problem
before. That went to a literature sweep, and the answer with all its caveats is
in docs/novelty.md. Short version: five things did not turn
up in the machine-learning literature, one control correctly did, and every
"not found" is a not-found over stated searches rather than a proof that nobody
has done it. If you know prior art, please open an issue — being corrected is
cheaper than being wrong in public.
| page | what's in it |
|---|---|
docs/mathematics.md |
every definition, theorem and formula |
docs/evidence.md |
every measurement, with what it was compared against |
docs/novelty.md |
the literature sweep, verdicts and search queries |
docs/corrections.md |
what was claimed, what refuted it, what changed |
MIT. See LICENSE.
Archived on Zenodo with a permanent DOI:
@software{sharma_monodromy_2026,
author = {Sharma, Teerth},
title = {monodromy: data analysis and machine learning without the Jacobian},
year = {2026},
version = {0.1.0},
doi = {10.5281/zenodo.22064739},
url = {https://github.com/teerthsharma/monodromy}
}teerthsharma.vercel.app · github.com/teerthsharma · teerths57@gmail.com
Built after the Jacobian conjecture fell, because the check it justified is still running in production everywhere.