AlphaEvolve Lowered the Matrix Multiplication Exponent—Not Your GPU Bill

A new preprint reports that AlphaEvolve helped lower the best known upper bound on the matrix multiplication exponent, usually written as the Greek letter omega, from $2.371339$ to $2.371177$. That is a genuine theoretical record. It is not a new matrix multiplication kernel, a measured GPU speedup, or a reason to expect a lower cloud bill.

The distinction matters because matrix multiplication powers neural-network training and inference. A headline about a better exponent can sound like immediate AI acceleration. In this case, the researchers used machine-learning techniques and AlphaEvolve to search a vast mathematical optimization problem. They then used a separate exact-arithmetic process to certify the candidate result.

The August 17 paper is only a preprint, and its promised verification code and discovered solution were not public as of August 20. The certificate therefore has not yet been independently reproduced in public. The careful conclusion is: the authors report a rigorously checked new upper bound, with an important reproducibility step still outstanding.

What does the matrix multiplication exponent mean?

The familiar schoolbook method multiplies two $n \times n$ matrices in roughly $n^3$ arithmetic operations. The exponent is $3$ because doubling the matrix dimension increases that leading operation count by about $2^3=8$.

In 1969, Volker Strassen showed that matrix multiplication could use fewer than cubic operations. That opened a long-running question: how close can the exponent get to $2$, the scale needed merely to write the $n^2$ entries in the answer?

Researchers formalize the question using omega, $\omega$. Informally, $\omega$ is the smallest exponent for which sufficiently large square matrices can be multiplied using about $n^\omega$ arithmetic operations, while allowing lower-order factors hidden by the asymptotic notation.

There are two boundaries to keep separate:

• The output itself gives a lower bound of $\omega \geq 2$.
• A discovered algorithm or mathematical construction gives an upper bound, such as $\omega < 2.371177$.

Lowering the upper bound does not reveal the true value of omega. It proves that the unknown answer is no larger than the new number. The gap between $2$ and $2.371177$ remains open.

The previous record, $\omega < 2.371339$, was published in the 2025 SODA proceedings. The new paper’s improvement is $0.000162$. That looks tiny, but progress in this area has been both small and difficult for decades. Independent reporting from Quanta provides the right context: these records help researchers understand the theoretical limits of the problem, while the laser method behind them is analyzed rather than run as a practical implementation.

What AlphaEvolve actually changed

The new result is not a story in which a language model directly invented the final proof. The work has four distinct layers: a mathematical reformulation, a large numerical search, AlphaEvolve-assisted program improvement, and exact certification.

1. Humans reformulated the optimization problem

Recent omega records use a refinement of the laser method, a theoretical technique for decomposing and analyzing matrix multiplication. The analysis can be expressed as a constrained, non-convex optimization problem. “Non-convex” means the landscape can contain many locally good points, so following a downhill direction does not guarantee finding the best answer overall.

The previous record searched the construction to a maximum recursion level of $3$, involving about 25,000 optimizable parameters. The new team reformulated the problem so it could reach recursion level $4$, where the search grows to nearly 7 million parameters.

That larger search space is not automatically better: it also becomes far harder to optimize. The contribution was making it computationally manageable.

2. Machine-learning tools made the search differentiable and parallel

Many of the variables are probability distributions. Rather than optimize constrained probabilities directly, the researchers represented them as unrestricted logits and converted those logits into probabilities with a softmax function. This is a standard machine-learning pattern.

They used the Sinkhorn-Knopp algorithm to handle maximum-entropy distributions, automatic differentiation to calculate gradients, and Adam to update the parameters. They implemented the system in JAX, reorganizing an irregular graph computation into masked, grouped tensors that GPUs could process in parallel.

This gradient-based system already improved the prior record. The paper says it reduced the bound by approximately $0.000097$ before AlphaEvolve was applied.

3. AlphaEvolve improved the optimizer program

AlphaEvolve is a coding agent that proposes program changes, runs candidates against automated evaluators, and evolves promising versions. Here, it did not multiply production matrices. It modified the program used to search for a better mathematical bound.

Each candidate optimizer took about five hours on a single GPU to produce a bound, according to the new paper. AlphaEvolve used that bound as its score and evolved the code to make the number smaller. The researchers report that an “evolving constructions” setup helped: a child optimizer began from the best solution found by its parent rather than starting over.

The division of credit is unusually clear in the paper:

Stage	Reported contribution
Previous published record	$\omega < 2.371339$
New gradient-based optimization	Improved the record by about $0.000097$
AlphaEvolve-refined optimization	Extended the total improvement to about $0.000162$
Final reported bound	$\omega < 2.371177$

AlphaEvolve extended an already successful human-designed and ML-enabled optimization system. Saying that AlphaEvolve alone “solved matrix multiplication” would erase both the mathematical setup and the team’s earlier numerical improvement.

4. Exact arithmetic checked the numerical candidate

A floating-point optimizer can return a promising number without proving that every mathematical constraint is truly satisfied. Tiny rounding errors matter when the claimed gain is only in the fourth decimal place.

The authors therefore describe a separate verification step. They rounded the floating-point solution to rational numbers, computed the derived quantities using exact rational arithmetic, and bounded logarithms in the conservative direction. This is intended to turn a numerical candidate into a valid certificate for the upper bound.

That separation is good computer-assisted mathematics: use fast approximate computation for discovery, then a stricter method for verification. But readers should distinguish the authors’ certification claim from public independent reproduction. The paper says the verification repository is being prepared; it was not linked from arXiv at publication time.

Why the new bound does not make GPU matrix multiplication faster

An asymptotic exponent describes how an operation count grows as $n$ becomes extraordinarily large. Real GPU performance depends on much more:

• the constants and lower-order terms hidden by asymptotic notation;
• the matrix sizes and shapes used by a model;
• memory movement, cache behavior, and communication between devices;
• numerical precision and stability;
• how effectively a kernel uses tensor cores and other hardware; and
• the overhead of turning a theoretical construction into executable steps.

The new paper does not provide a CUDA, Triton, JAX, or vendor-library kernel implementing the laser method. It reports a better analysis of what is possible in principle.

An illustrative calculation shows why the exponent change alone cannot predict a useful runtime gain. If two imaginary algorithms had equal constants and costs exactly proportional to $n^{2.371339}$ and $n^{2.371177}$, the smaller exponent would reduce the leading term by the following amounts:

Matrix dimension $n$	Illustrative reduction in the leading term
$1{,}000$	about $0.11\%$
$1{,}000{,}000$	about $0.22\%$
$1{,}000{,}000{,}000{,}000$	about $0.45\%$

These are not benchmarks. The equal-constant assumption is unrealistic, and the laser-method construction can carry enormous hidden costs. The table only demonstrates how slowly a $0.000162$ exponent difference compounds. For practical sizes, a tuned algorithm with a worse asymptotic exponent can easily be faster.

This also separates the result from AlphaEvolve’s other matrix multiplication work. Its earlier system paper reported a 48-multiplication construction for a particular $4 \times 4$ complex-valued problem. The omega preprint instead improves an asymptotic bound through a different optimization pipeline. Neither result is evidence that an ordinary GPU matrix multiply became cheaper overnight.

Why the result still matters

The immediate value is methodological and theoretical.

First, the team scaled a delicate optimization from roughly 25,000 to 7 million parameters by translating ideas from modern machine learning into a computer-assisted proof search. That creates a concrete bridge between optimization engineering and theoretical computer science.

Second, the result shows a useful role for an evolutionary coding agent. AlphaEvolve searched over optimizer programs, not just numerical settings. The evaluator supplied a precise objective, while the human researchers supplied the mathematical representation, compute system, verification standard, and interpretation.

Third, even a small upper-bound improvement narrows what researchers need to explain. If the true exponent is $2$, current laser-method analyses remain far from it. If it is larger, better upper and lower bounds help map the territory.

For practitioners, the most transferable lesson is not a faster general matrix multiply. It is a workflow:

1. express a difficult scientific search as an evaluable program;
2. use differentiable optimization and hardware parallelism where they fit;
3. let a coding agent explore program-level changes under a measurable score; and
4. verify the winning numerical result with a method designed to rule out approximation error.

That workflow is more interesting than the dramatic version of the headline because it shows exactly where the AI system helped—and where human mathematical judgment remained essential.

What evidence should come next?

The first checkpoint is the promised repository containing the verification code and discovered solution. Independent researchers should be able to run the certificate, inspect the direction of every numerical bound, and reproduce $\omega < 2.371177$.

The next checkpoint is peer review. The paper is an arXiv preprint, not a peer-reviewed publication. Review may confirm the result, identify a technical issue, or clarify which part of the construction deserves the most weight.

Finally, watch for follow-up work that separates three questions often collapsed into one headline:

• Can the optimizer find an even lower certified asymptotic bound?
• Can the method teach researchers something new about the limits of the laser approach?
• Can any related idea become a stable, hardware-aware implementation for realistic matrices?

Only the first question is answered by the reported record. For a refresher on the linear algebra underneath matrix multiplication, start with our guide from vectors to embeddings. For a framework to assess reported improvements, see how evaluations shape AI products.

Sources

1. Improving the matrix multiplication exponent with modern optimization and AlphaEvolve
2. AlphaEvolve: A coding agent for scientific and algorithmic discovery
3. More Asymmetry Yields Faster Matrix Multiplication
4. New Breakthrough Brings Matrix Multiplication Closer to Ideal