OpenAI Cracked Three ‘Impossible’ Math Barriers. The Cracks Are Almost Invisible.

The first reaction is disbelief. For integer multiplication and FFT, the exponents look like rounding errors dressed up as theorems. A saving of 2−182 in an exponent is not a breakthrough in any ordinary sense. It is a number so small that writing its distance from zero takes more digits than there are atoms in a person. The prose around these results does not help. It reads like AI-generated mathematics: simple concepts explained at length, difficult constructions mentioned in passing, new terminology introduced without definition, no sense of proportion.

The instinct that something is wrong is partly correct. These results have no practical value. It is also partly wrong. OpenAI has punched a hole in a theoretical barrier that was widely believed to be absolute. The holes are microscopic. They exist.

1. Matrix multiplication: the one result that can be verified

Of the three, matrix multiplication is the one that feels like mathematics rather than a hallucination. OpenAI pushed the exponent ω from roughly 2.371 to 9/4=2.25 over the complex numbers. This is a single-step reduction of about 0.12. It is the largest jump since the late 1970s, when Strassen’s algorithm and its immediate successors brought the exponent below 2.5.

Matrix multiplication is the primitive under linear algebra, optimization, graph algorithms, and neural network training. Every layer of a transformer is, at bottom, a matrix multiplication. The exponent ω governs the asymptotic cost of this primitive. Reducing it from 2.371 to 2.25 does not change what is computable. It changes the theoretical map of what is efficiently computable.

The result comes with Lean verification. The proof was formalized and checked by the Lean kernel, and later extended from the complex numbers to arbitrary fields, with Lean verification passing in both cases. That gives the result a level of trust the prose alone cannot. In a release of 722 manuscripts, only 162 had Lean formal proofs. The matrix multiplication result is one of the few a skeptical reader can accept without trusting the prose.

Practical limits are severe. Asymptotic improvements in ω come with hidden constants that are enormous. Algorithms that achieve ω=2.25 are galactic. They only beat standard matrix multiplication for input sizes far beyond any matrix that will ever be stored in physical memory. The result does not give us a faster GPU kernel. It tells us that 2.25 is possible.

2. Integer multiplication: a barrier that was not a barrier

The integer multiplication result is where disbelief is strongest and where the writing is worst. OpenAI claims a deterministic algorithm with complexity

T(n)=O(n(logn)1−κ),κ=2−182

for multiplying two n-bit integers.

Context matters. In 2019, Harvey and van der Hoeven proved integer multiplication can be done in O(nlog⁡n) bit operations, confirming a conjecture of Schönhage and Strassen from 1971. After that, many read nlog⁡n as optimal. The conjecture was a theorem, and the theorem was read as the end of the story.

OpenAI’s result says this reading is wrong. The exponent is not 1. It is 1−2−182. The saving is asymptotic. The ratio of the new complexity to nlog⁡nnlogn tends to zero as n grows. The rate is so slow that no computation in the observable universe could detect the difference. To make the (log⁡n)−κ factor materially smaller than 1, n would need to be larger than the number of atoms in the observable universe, raised to a power that is itself astronomical.

This is why the result reads like a joke. The joke has a point. We cannot multiply integers faster in any practical sense. The nlog⁡nnlogn barrier is not absolute. It follows from a model and a set of techniques. Change the techniques, and the barrier moves. It moves by an infinitesimal amount, but it moves. Later work tightened κκ from 2−182 to 2−34, then to roughly 10−5. The crack is widening.

3. FFT: the barrier that was never as solid as it looked

The FFT result is the most conceptually interesting. The barrier it breaks was never a theorem in the way people thought. It was a theorem with a condition, and the condition was quietly ignored for fifty years.

Morgenstern’s theorem from 1973 states that if the constants in a linear circuit for computing the Fourier transform are bounded, then the circuit requires Ω(nlog⁡n) operations. This is a lower bound. It is often cited as the reason FFT cannot be improved. The bound depends on boundedness. Without it, the theorem says nothing.

OpenAI’s FFT result exploits this gap. The algorithm lets intermediate values grow enormously, by factors that would correspond to energies of 10200 in a physical analogy. It then relies on precise algebraic cancellation to bring the final result back to the correct value. The intermediate states have no physical meaning. They are not unitary. They do not preserve energy. They do not have local frequency or phase. They are algebraic artifacts, and they cancel.

Published saving: ε=10−13 in the exponent:

O(n(logn)1−10−13)

This is smaller than the integer multiplication saving by many orders of magnitude. It is also more radical. The integer multiplication barrier was a conjecture. The FFT barrier was a theorem with a condition. OpenAI found the condition and stepped around it.

To understand how, abandon the physical picture. The DFT is a Vandermonde matrix evaluated at roots of unity. Given P(t)=c0+c1t+⋯+cn−1tn−1, the DFT evaluates P at the n roots of unity. The FFT works because the roots of unity fold under squaring:

(ωk+n/2)2=(ωk)2

This is an algebraic symmetry. It halves the problem, recursively, and yields O(nlog⁡n).

If you insist that every intermediate step preserve norm, you impose a condition the algebra does not require. If you let intermediate values explode and then cancel, you open the door to constructions Morgenstern’s theorem does not cover. OpenAI walked through that door.

The construction uses shear transformations and quadratic phase factors to entangle coordinate axes that classical algorithms treat as independent. Standard approaches scan each axis separately, producing a factor of k≈log⁡n. The new approach scans along tilted directions in a high-dimensional algebraic variety. The tilted scans overlap in ways that allow algebraic cancellation, called syzygies, so the effective number of scans is slightly less than k. The saving is 1−ε per level of recursion. With d=log⁡k0(log⁡mN) levels, the total saving becomes (log⁡N)−δ for some tiny δ.

The result is not a faster FFT. The exponent saving 10−13 only becomes visible when log⁡n is around 213700, far beyond any input that could exist. It is a theoretical proof that the nlog⁡n bound, in the unbounded-coefficient model, is not absolute.

4. What the three results have in common

The three results share a structure. Each takes a barrier believed to be absolute and shows the barrier is conditional. The conditions differ. The matrix multiplication barrier was a technical record, not a lower bound. The integer multiplication barrier was a conjecture about optimality. The FFT barrier was a theorem with a boundedness condition. In each case, the condition was overlooked, and OpenAI found a way around it.

All three are practically irrelevant. The matrix multiplication algorithm has hidden constants that make it unusable for any finite matrix. The integer multiplication saving requires inputs larger than the observable universe. The FFT saving requires log⁡n to be an astronomically large number. None will make NumPy faster. None will break RSA. None will change how anyone writes code.

They will change how theorists think about lower bounds. Theoretical computer science is full of barriers that turned out to be technique-limited rather than fundamental. Strassen’s 1969 result showed matrix multiplication need not take n3 time. It took decades to bring the exponent down, but the first crack was the important one. Khachiyan’s ellipsoid method was impractical but proved linear programming was in P. Interior-point methods followed and became practical. The FFT result is in that tradition. It is a crack. Cracks sometimes widen.

5. Why the writing is so bad, and why it affects verification

The prose around these results is a separate problem. The integer multiplication and FFT manuscripts are nearly unreadable: simple concepts explained at length, difficult constructions asserted without adequate definition, low ratio of words to verifiable content. This affects verification. If a result is presented in a way that resists comprehension, it resists checking. The matrix multiplication result is readable partly because it is short and partly because it is Lean-verified. The integer multiplication and FFT results are not in that category. The community has built on them, which is weak evidence they are correct. They are not presented in a form that invites independent verification.

This affects the broader release of 722 manuscripts. Many results are not Lean-verified. OpenAI acknowledges that some unformalized results could contain errors. Three manuscripts were withdrawn within a day of release. In that context, the matrix multiplication result stands out as the one that can be trusted on its own terms. The integer multiplication and FFT results require a different kind of trust: trust that the construction works, trust that the cancellation is valid, trust that the tiny exponent is not an artifact of a mistake somewhere in a long chain of algebraic manipulations.

The community has already extended the work, tightening the exponents and generalizing the constructions. The burden of verification is higher than it should be. The writing does not help.

6. What to take away

The three results are theoretical possibility proofs, not engineering breakthroughs. They tell us that barriers we thought were walls are thresholds. They can be crossed, if only by an infinitesimal amount. The matrix multiplication result is the most useful because it is verifiable and because the improvement is large enough to matter to complexity theory. The integer multiplication result is the most shocking because it contradicts a conjecture widely believed to be settled. The FFT result is the most conceptually interesting because it reveals that a fifty-year-old lower bound was conditional, and the condition had been forgotten.

None will make your code faster. All change what is theoretically possible. That is not nothing. It is also not much. It is a crack in a wall. Whether it widens is a question for the next decade.