A NEW RECORD FOR MULTIPLYING GRIDS OF NUMBERS

Multiplying two matrices — grids of numbers — is one of the most basic operations in computing. Done the schoolbook way, the cost of multiplying two n-by-n grids grows like n³. Volker Strassen’s 1969 algorithm was the first to do better — “subcubic”, in the paper’s words — and since then mathematicians have measured progress with a single number: the exponent ω (omega), the smallest power of n that suffices as the grids grow.

Strassen brought it below 2.81. Decades of work, listed in the paper, have pushed it down to around 2.37, with ever-smaller steps. In 2026, Emilien Dupont and colleagues reached 2.371177. Reza Zadeh, of the company Matroid, Inc., now proves ω < 2.37115924.

Table listing years, authors and upper bounds on the matrix multiplication exponent, from 2.807 in 1969 to 2.37115924 in 2026.

Selected improvements in the upper bound on ω, from Strassen in 1969 to this paper. — Table 1, Zadeh (2026), arXiv:2610.10593, CC BY 4.0.

A recipe with 212,820 settings

These records do not come from a cleverer trick for small grids. They come from an algebraic object called the Coppersmith–Winograd tensor, which can be cut up and recombined, recursively, into many independent matrix products. How it is cut is governed by a huge set of choices: probability distributions, entropy penalties and matrix sizes defined level after level. Any valid set of choices gives a valid bound; the art is to find a good one.

Building on the framework of Josh Alman and colleagues and on Dupont and colleagues’ formulation, Zadeh tuned 212,820 numbers at once, with three refinements:

Rescaling by importance. Some pieces of the construction appear only rarely, so their effect on the result is tiny and an optimiser barely moves them. Each number was rescaled according to how much weight its piece carries.
Six dials for the bottlenecks. The final exponent is set by the weakest of three competing quantities at three stages. A separate correction used just six controls to keep them balanced.
Exact export. The final recipe was converted into exact fractions with denominators of 2⁹⁶.

Proof by checking

The bound is a computer-assisted proof. A short program, using only Python’s standard library — no network, no model, no extra package — rebuilds every distribution from the exact fractions and evaluates the result with guaranteed rounding. It finds that the key quantity is positive, by about 8.5 billionths, which proves the bound. The author stresses what this does not cover: the program is auditable code, not a formalisation of the whole theory in a proof assistant, and the search was local, with no claim that the recipe is the best possible.

The author also writes that generative AI tools, which are not named, assisted the numerical exploration, the software and the manuscript, and that early code drew on computational notes shared publicly by Eric Naslund. A separate public computer certificate, released on 5 October 2026, had reached 2.371169353; the new value is lower still.

Faster, in theory

The gain over Dupont and colleagues is 0.00001776 in the exponent. Like all bounds obtained this way, the guarantee is asymptotic: the exponent alone does not say from which matrix size the new algorithm would actually beat existing ones. What it changes is the best known answer to a question that has run since 1969 — how fast, in principle, can grids of numbers be multiplied?