AlphaTensor
Last reviewed
Jun 3, 2026
Sources
8 citations
Review status
Source-backed
Revision
v1 · 1,638 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Jun 3, 2026
Sources
8 citations
Review status
Source-backed
Revision
v1 · 1,638 words
Add missing citations, update stale details, or suggest a clearer explanation.
AlphaTensor is an artificial-intelligence system built by DeepMind that searches for faster algorithms to multiply matrices. It was introduced in a paper titled "Discovering faster matrix multiplication algorithms with reinforcement learning," published in Nature on 5 October 2022. The system is an extension of AlphaZero, the deep reinforcement-learning program that DeepMind had earlier used to master Go, chess, and shogi. AlphaTensor recast the open mathematical problem of finding low-cost matrix-multiplication algorithms as a single-player game, then learned to play that game well enough to rediscover decades of human results and, in a few cases, to surpass them.[1][2][3]
The headline finding was an algorithm for multiplying two 4x4 matrices using 47 scalar multiplications in arithmetic modulo 2, fewer than the 49 required by applying Strassen's classic method twice. The work drew wide attention as one of the first demonstrations that a game-playing reinforcement-learning agent could contribute to a long-studied question in pure algorithmics, though commentators noted that the most eye-catching result was specific to a finite field rather than a speedup for ordinary numerical computing.[1][2][4]
Multiplying two matrices is one of the most heavily used operations in scientific computing, computer graphics, and machine learning, so even small constant-factor savings can matter at scale. The schoolbook method for multiplying two n-by-n matrices uses n cubed scalar multiplications, which for two 2x2 matrices means eight multiplications.[3][5]
In 1969 Volker Strassen showed that two 2x2 matrices can be multiplied using only seven scalar multiplications instead of eight, at the cost of extra additions. Applied recursively to larger matrices, Strassen's trick lowers the asymptotic exponent of matrix multiplication below three. The number of multiplications matters more than the number of additions because, in a recursive scheme, the multiplications are what get applied to ever-larger submatrices, so reducing them improves the asymptotic cost. Half a century of effort had refined the asymptotics, but for many small fixed sizes the best known number of multiplications had not moved in years, and the space of possible algorithms was widely believed to be largely mapped out.[2][3][5]
AlphaTensor builds on a standard reformulation: any bilinear algorithm for a fixed matrix-multiplication size corresponds to a decomposition of a fixed three-dimensional array called the matrix-multiplication tensor. Writing that tensor as a sum of rank-1 terms (outer products of three vectors) yields a valid multiplication algorithm, and the number of terms in the decomposition, its rank, equals the number of scalar multiplications the algorithm uses. Finding a fast algorithm is therefore the same as finding a low-rank decomposition of the tensor, a problem known to be NP-hard in general.[1][3][6]
DeepMind turned this into a single-player game called TensorGame. The starting position is the target tensor. On each move the agent picks three vectors, forms their outer product, and subtracts it from the current tensor. The episode ends when the tensor has been reduced entirely to zeros, at which point the sequence of moves is a provably correct decomposition. A small negative reward at every step pushes the agent toward decompositions that use as few moves, and therefore as few multiplications, as possible. To keep results exact and avoid floating-point error, the entries the agent was allowed to choose were restricted to a small set such as {-2, -1, 0, 1, 2}.[1][3][6]
The game is extraordinarily large: DeepMind estimated more than 10 to the 33rd power possible moves at each step, far beyond the branching factor of Go. To cope, AlphaTensor pairs a deep neural network with Monte Carlo tree search in the AlphaZero style. The network uses a transformer-based architecture with axial attention to read the tensor's state and an autoregressive policy head to propose the next set of vectors, while a value head estimates the eventual rank. Training mixed reinforcement learning on self-play with supervised signal from synthetic examples, generated by sampling random vector triples and multiplying them out to produce tensors with a known decomposition. The agent could be trained over different arithmetic domains, including the field with two elements and standard arithmetic, and basis changes served as data augmentation to enrich the positions seen.[1][3][6]
AlphaTensor rediscovered Strassen's 2x2 algorithm within minutes of training and reproduced the best known algorithms for many other sizes. For a given size it often found a large and diverse collection of distinct algorithms, in some cases thousands, suggesting that the space of efficient matrix-multiplication algorithms is richer than had been assumed.[1][2][3]
Its most-cited new result was in arithmetic modulo 2, where the agent found a way to multiply two 4x4 matrices with 47 multiplications, beating the 49 that come from two levels of Strassen (7 squared). The system also reported a 5x5 algorithm in the same setting using 96 multiplications, below the previous figure of 98. Over standard arithmetic the picture was more modest: AlphaTensor generally matched rather than beat the known records for square matrices, but it did improve several non-square cases that hold for ordinary real numbers. A widely quoted example multiplies a 4x5 matrix by a 5x5 matrix in 76 multiplications, down from a previous best of 80.[1][2][4]
| Size and setting | AlphaTensor | Previous best | Notes |
|---|---|---|---|
| 4x4, modulo 2 | 47 | 49 (two-level Strassen) | First improvement on two-level Strassen in this setting since 1969 |
| 5x5, modulo 2 | 96 | 98 | Later improved to 95 by other researchers |
| 4x5 times 5x5, standard arithmetic | 76 | 80 | A non-square improvement that holds over the real numbers |
The distinction between the two arithmetic settings is the most important caveat to the headline number. The 4x4 result is a statement about the field with two elements, not a faster way to multiply matrices of real or floating-point numbers, and the paper reported only a handful of improvements that carry over to standard arithmetic, all for rectangular rather than square sizes.[1][4][7]
Because the number of multiplications is not the only thing that determines real-world speed, DeepMind also tuned AlphaTensor to optimize for the running time on a specific processor rather than for rank alone. By folding measured execution time into the reward, the agent discovered algorithms tailored to a particular Nvidia V100 GPU and to a Google TPU v2. On those chips the resulting algorithms multiplied large matrices roughly 10 to 20 percent faster than commonly used implementations, with the company reporting figures on the order of 8.5 percent on the V100 and about 10.3 percent on the TPU in its benchmarks.[1][3][6]
These speedups came with conditions. An algorithm tuned for one accelerator did not necessarily perform well on another, and independent commentary noted that the reported gains were measured against ordinary block matrix multiplication on large matrices rather than against an optimized Strassen implementation, so the baseline matters when interpreting the numbers.[6][7]
Coverage in outlets such as Quanta Magazine and MIT Technology Review treated the work as a genuine and surprising result while stressing its limits. The record-setting 4x4 algorithm is valid only in modulo 2 arithmetic, and for everyday floating-point computation the standard multiplication kernel often remains preferable, partly because modern hardware executes fused multiply-add operations cheaply and partly because methods that save multiplications can introduce more additions and numerical-stability concerns. In other words, fewer multiplications does not automatically translate into a faster or more accurate program.[2][4][7]
The clearest sign that the search space was not exhausted came from human mathematicians. Within about a week of the paper's release, Manuel Kauers and Jakob Moosbauer used a conventional computer search, seeded in part by AlphaTensor's own output, to push the 5x5 modulo 2 result from 96 multiplications down to 95, and they independently found a separate 47-multiplication algorithm for the 4x4 case. Their note, given the tongue-in-cheek title "The FBHHRBNRSSSHK-Algorithm" after the initials of the DeepMind authors, underscored that the AlphaTensor results were a starting point rather than a final answer, and that classical techniques could sometimes extend them quickly.[2][4]
AlphaTensor is notable less for any single record than for what it demonstrated about method. It showed that a game-playing reinforcement-learning agent could be pointed at a well-defined mathematical search problem, the decomposition of a tensor, and turn up algorithms that experts had not found, including in regions of the search space that researchers had assumed were not worth exploring. It is part of a broader DeepMind program of using learning-based search for algorithm discovery, a thread that continued with AlphaDev, which found faster sorting and hashing routines later adopted into standard libraries, and with related systems such as MuZero that share the AlphaZero lineage.[1][3][8]
At the same time, the episode became a frequently cited example of how AI results in mathematics should be read carefully. The most striking claim applied to a specific finite field, the practical speedups depended on hardware and baseline choices, and human researchers improved on the new records almost immediately. AlphaTensor thus stands as both a real contribution to the study of matrix-multiplication algorithms and a case study in distinguishing a headline from its caveats.[2][4][7]