# AlphaEvolve: Fewer Multiplications

Laplace’s Mini World · Plate F62 · AI

> Among ways that nest level by level, 4 × 4 matrices took 49 multiplications from 1969. In 2025 a loop that edits and scores programs found 48, with complex numbers.

- Interactive model: https://world.lapla.si/en/alphaevolve/
- Embed: https://world.lapla.si/embed/en/alphaevolve/
- 中文: https://world.lapla.si/zh/alphaevolve/
- Updated: 2026-11-04

## 01 From 49 to 48

Multiplying two 4 × 4 matrices by the definition takes 64 multiplications. Since 1969, the ways that can be nested inside bigger matrices have needed at least 49 over the real and complex numbers. In May 2025 Google DeepMind announced that AlphaEvolve had found a way with 48, with complex coefficients.

Those coefficients are exact, and each can be checked. The seven blocks in front, the eight behind them, the cube and the record plate show where that one multiplication comes from, and how it was found.

*4 × 4 · 49 since 1969 · 48 in 2025, complex coefficients*

## 02 Eight Multiplications

Start with 2 × 2. Each entry of the product C is a row of A times a column of B, entry by entry, added up: C₁₁ = A₁₁B₁₁ + A₁₂B₂₁. Four entries, two multiplications each: 8 multiplications and 4 additions.

The eight blocks in the back row are those eight multiplications, one block each. For n × n matrices this way takes n³ multiplications: 64 for 4 × 4, a billion for 1000 × 1000.

*2 × 2 by the definition: 8 multiplications · 4 additions · n × n: n³ multiplications*

## 03 Seven Will Do

In 1969 Strassen published a way with 7 multiplications. First compute seven products such as M₁ = (A₁₁ + A₂₂)(B₁₁ + B₂₂): each side is a sum or difference of entries of A, or of B. Then add and subtract the seven to make the four entries of C.

The price is more additions: 18 instead of 4. The seven blocks in the front row are those seven products. In 1971 it was proved that without commutativity, a 2 × 2 product needs at least 7 multiplications.

*7 multiplications · 18 additions and subtractions · 2 × 2 needs at least 7 (proved 1971)*

## 04 A Block of Cells

There is another way to write it. Put the four entries of A along one edge, the four of B along another, the four of C upwards: 4 × 4 × 4 = 64 cells. A cell holds 1 when that entry of A times that entry of B goes into that entry of C, and 0 otherwise.

For a 2 × 2 product exactly 8 cells hold 1: the 8 multiplications. Cut the cube into its four layers by C: the bottom layer is C₁₁, and its two lit cells are A₁₁B₁₁ and A₁₂B₂₁.

*4 × 4 × 4 = 64 cells · 8 hold 1 · each layer is one entry of C*

## 05 One Product, One Piece

Each multiplication is one piece of the cube: which entries of A are added, which of B, and which entries of C the result goes into. The three lists of weights, multiplied together, fill a block of signed cells. A way to multiply is a set of pieces that add up to exactly the cube, and the number of pieces is the number of multiplications.

Strassen’s seven pieces fill 32 cells, some plus and some minus. Put them into the cube and in 12 cells a plus meets a minus and cancels; what is left is exactly the 8. Finding fewer multiplications means finding fewer pieces.

*Seven pieces · 32 cells · 12 cancel, plus against minus · 8 remain*

## 06 Savings That Compound

Why does one multiplication matter? Strassen’s method never swaps the order of a product, so its entries can be blocks of a matrix. A 4 × 4 matrix is a 2 × 2 grid of 2 × 2 blocks: the outer level takes 7 block products and each of those takes 7 inside, 7 × 7 = 49 in all.

The cube says the same: a 4 × 4 product is 16 × 16 × 16 cells. Number the entries block by block and its 64 ones fall into 8 groups of 8, with the 2 × 2 pattern inside each group and among the groups. That is what is etched in the crystal at the back.

The bigger the matrix, the more levels, the more saved: for n = 2ᵏ the definition takes 8ᵏ multiplications and Strassen 7ᵏ, about n to the power 2.81. At 1024 × 1024 that is about 1.07 billion against about 282 million, roughly three quarters fewer.

If the entries are numbers whose order can be swapped, Winograd’s method of 1968 multiplies 4 × 4 matrices with 48. But it needs that swap, so with blocks for entries it goes wrong and cannot be nested. 49 is the record among the ways that can.

*n = 2ᵏ: definition 8ᵏ = n³ · Strassen 7ᵏ ≈ n^2.81 · 1024 × 1024: about 1.07 billion against 282 million*

## 07 47, in Another Arithmetic

In 2022 DeepMind’s AlphaTensor turned splitting the cube into a single-⁠player game and learned to play it by reinforcement learning. For 4 × 4 it found a split into 47 pieces, but only in arithmetic mod 2, where there are only 0 and 1 and 1 + 1 = 0.

With ordinary numbers that split does not hold. Over the real and complex numbers the best 4 × 4 way that can be nested stayed at Strassen’s two levels, 49.

*AlphaTensor, 2022 · 4 × 4: 47 in arithmetic mod 2 · still 49 with ordinary numbers*

## 08 Edit, Run, Score

AlphaEvolve does not split the cube itself: it edits a program. People write a first program that runs and a function that scores; a database keeps the programs tried so far and their scores. Each round, programs from the database go into a prompt, and two language models, Gemini 2.0 Flash and 2.0 Pro, propose changes, written as blocks of “find these lines, replace them with those”.

Each changed program goes to the evaluators, which really run it and score it with the scoring function. The good ones go back into the database to be changed again. On the plinth this is only sketched: three candidates go into the cube in turn, red cells are where a sum is wrong, and the record plate’s 2 × 2 row follows the round’s best score from 8 to 7.

For matrix multiplication the program being changed searches for a split by gradient descent: how to start, how to measure the error, which optimiser to use. To evaluate it, it is run from different random seeds and scored by the fewest pieces it reaches on a set of sizes; every weight is rounded to a whole or half number, so the split is exact. What is searched is a program, not a move; for the game kind of search, see “AlphaGo: Search Plus Intuition”.

*Database → prompt → language models propose changes → run and score → the good ones go back*

## 09 Forty-⁠Eight Pieces

The cube of a 4 × 4 product has 16 × 16 × 16 = 4096 cells, 64 of which hold 1: the 64 in the crystal. The split AlphaEvolve found has 48 pieces, with weights taking only nine values: 0, ±½, ±½i and ±½ ± ½i.

The weights are published. We added the 48 pieces up cell by cell in exact arithmetic, and all 4096 cells match the cube. The weights contain i, so these multiplications are done in complex numbers.

The paper calls it the first method to find such a way; a complex 48 found by numerical methods had, however, been reported in 2024. In June 2025 others turned AlphaEvolve’s split into one with rational weights only, valid wherever one can divide by 2. Whether 48 is the fewest, nobody knows.

*4 × 4: 4,⁠096 cells, 64 hold 1 · 48 pieces · weights 0, ±½, ±½i, ±½ ± ½i · every cell checked*

## 10 It Needs a Score

The loop turns because a program can score every candidate automatically: whether a split is right and how many pieces it has can simply be computed. The paper itself names its main limitation: it handles only problems for which an automated evaluator can be written.

The same method has been used elsewhere: a scheduling rule for Google’s data centres that recovers on average about 0.7% of compute that would otherwise sit idle, and a tiling rule for a matrix-⁠multiplication kernel used to train Gemini, 23% faster on average and about 1% off the whole training time. Those are other programs, unrelated to the 48.

Fewer multiplications are not always faster, either. Two levels of Strassen on a 4 × 4 product take 49 multiplications but 198 additions and subtractions, against 48 additions by the definition; they also move more data and have looser bounds on rounding error. Neither the paper nor the announcement says the 48 made any real program faster. For hardware built to multiply matrices, see “The TPU and Its Systolic Array”.

*Only for problems a program can score · 4 × 4, two levels of Strassen: 49 multiplications, 198 additions · definition: 64 and 48*

## 11 Taken Apart

On the plinth: the cube of the 2 × 2 product on its brass plate, up on a stone step; in front, Strassen’s seven on a stone rail, and one step up behind them the schoolbook eight, on the same spacing and one place longer; at the back right, the record plate, and between it and the cube the crystal of the 4 × 4 product rises.

*Product cube · the seven · the eight · crystal · record plate*

## 12 The Bench

Two 2 × 2 matrices, multiplied both ways: 8 multiplications by the definition, 7 by Strassen’s, the same answer. “New numbers” picks two matrices at random; the seven pieces go into the cube one by one, and the readout shows the product being made.

Then pick a matrix size and see how many multiplications it takes: n³ by the definition; 7ᵏ with Strassen at every level; blocks of 4 × 4 done with 48, nested together with 7. The counts are multiplications only, computed by this page from the formulas; they are not running times, and not always today’s best.

*Multiplications only · computed by this page · not running times*

**Try this**: In the lab, set the matrix size to 1024: how many multiplications does the definition take, and how many with Strassen at every level? What share is saved?

## What the model leaves out

The cube, the blocks, the record plate and the crystal are this page’s model of the arithmetic, not objects from any laboratory. The cube has A left to right, B front to back and C upwards; the small blocks keep the same directions. The crystal shows only where its 64 ones are, not the 48-piece split. The “edit, run, score” animation is a sketch: the real AlphaEvolve runs its evaluations on many machines at once, and nobody drops pieces into a cube; its three candidates (a wrong one, the schoolbook eight, Strassen’s seven) show what a score is, not a record of its runs.

## Easy to get wrong

AlphaEvolve does not think up mathematics on its own: people write the first program and the scoring function, language models propose changes to the program, evaluators run and score them, and the scores decide what is kept. “49 since 1969” is only about ways that never swap the order of a product, can be nested, and work over the real or complex numbers: if the order may be swapped, Winograd’s method of 1968 uses 48 for 4 × 4, and in arithmetic mod 2 there has been a 47 since 2022. A complex 48 found numerically was reported in 2024; AlphaEvolve’s weights are exact, and since June 2025 there has also been a 48 with rational weights only. All these counts are of multiplications, and fewer multiplications are not always faster. 7 has been proved the fewest for 2 × 2; the fewest for 4 × 4 is not known.

## Common questions

### What did AlphaEvolve find in matrix multiplication?

Since 1969, the ways that can be nested inside bigger matrices have needed at least 49 over the real and complex numbers. In May 2025 Google DeepMind announced that AlphaEvolve had found a way with 48, with complex coefficients.

See: [01 From 49 to 48](https://world.lapla.si/en/alphaevolve/#record)

### How does Strassen’s algorithm use only 7 multiplications?

First compute seven products such as M₁ = (A₁₁ + A₂₂)(B₁₁ + B₂₂): each side is a sum or difference of entries of A, or of B. Then add and subtract the seven to make the four entries of C.

See: [03 Seven Will Do](https://world.lapla.si/en/alphaevolve/#seven)

### Why does one multiplication fewer matter?

Strassen’s method never swaps the order of a product, so its entries can be blocks of a matrix. A 4 × 4 matrix is a 2 × 2 grid of 2 × 2 blocks: the outer level takes 7 block products and each of those takes 7 inside, 7 × 7 = 49 in all.

See: [06 Savings That Compound](https://world.lapla.si/en/alphaevolve/#levels)

### How does AlphaEvolve work?

AlphaEvolve does not split the cube itself: it edits a program. People write a first program that runs and a function that scores; a database keeps the programs tried so far and their scores.

See: [08 Edit, Run, Score](https://world.lapla.si/en/alphaevolve/#loop)

### What problems can AlphaEvolve be used on?

The loop turns because a program can score every candidate automatically: whether a split is right and how many pieces it has can simply be computed. The paper itself names its main limitation: it handles only problems for which an automated evaluator can be written.

See: [10 It Needs a Score](https://world.lapla.si/en/alphaevolve/#limits)

## Sources

1. [A. Novikov et al. (2025): AlphaEvolve: A coding agent for scientific and algorithmic discovery, arXiv:2506.13131 (the loop’s four parts; 48 multiplications for 4 × 4 complex matrices; limited to problems with an automated evaluator)](https://arxiv.org/abs/2506.13131)
2. [Google DeepMind (14 May 2025): the AlphaEvolve announcement (0.7% of compute, a 23% faster kernel)](https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/)
3. [google-⁠deepmind/alphaevolve\_results (the 48-piece decomposition’s coefficients and a check)](https://github.com/google-deepmind/alphaevolve_results)
4. [V. Strassen (1969): Gaussian elimination is not optimal, Numerische Mathematik 13, 354⁠–⁠356 (seven products; 7 multiplications, 18 additions)](https://doi.org/10.1007/BF02165411)
5. [J. E. Hopcroft and L. R. Kerr (1971): SIAM J. Appl. Math. 20, 30⁠–⁠36 (without commutativity, 2 × 2 needs at least 7)](https://doi.org/10.1137/0120004)
6. [M. Bläser (2013): Fast Matrix Multiplication, Theory of Computing Graduate Surveys 5 (a survey; the rank of the 2 × 2 product is 7; Strassen works over non-⁠commutative rings)](https://theoryofcomputing.org/articles/gs005/)
7. [R. P. Brent (1970): Algorithms for matrix multiplication, Stanford STAN-⁠CS-⁠70-157 (Winograd’s inner-⁠product method: (mp + m + p)n/2 multiplications, commutative only)](https://maths-people.anu.edu.au/~brent/pub/pub002.html)
8. [A. Fawzi et al. (2022): Discovering faster matrix multiplication algorithms with reinforcement learning, Nature 610, 47⁠–⁠53 (multiplication as a 3-D tensor; 47 for 4 × 4 in arithmetic mod 2)](https://doi.org/10.1038/s41586-022-05172-4)
9. [I. E. Kaporin (2024): Comput. Math. Math. Phys. 64, 1881⁠–⁠1891 (a 4 × 4 scheme with 48 multiplications and complex coefficients, found numerically)](https://doi.org/10.1134/S0965542524701021)
10. [J.-G. Dumas, C. Pernet and A. Sedoglavic (2025): arXiv:2506.13242 (a 48-multiplication scheme with rational coefficients, valid wherever 2 can be divided by)](https://arxiv.org/abs/2506.13242)
11. [A. Sedoglavic: Fast matrix multiplication algorithms catalogue (best-⁠known counts for each size, October 2026)](https://fmm.univ-lille.fr/)
12. [J. Huang, T. M. Smith, G. M. Henry and R. A. van de Geijn (2016): arXiv:1605.01078 (multiplications traded for additions, at the cost of more data movement, memory and some numerical stability)](https://arxiv.org/abs/1605.01078)
13. [Y. Moran, O. Schwartz and S. Yuan (2026): arXiv:2602.13171 (fast matrix multiplication is often slower in practice; complex coefficients add overhead)](https://arxiv.org/abs/2602.13171)

## Data

AlphaEvolve and its results after A. Novikov, N. Vũ, M. Eisenberger, E. Dupont, P.-S. Huang, A. Z. Wagner, S. Shirobokov, B. Kozlovskii, F. J. R. Ruiz, A. Mehrabian, M. P. Kumar, A. See, S. Chaudhuri, G. Holland, A. Davies, S. Nowozin, P. Kohli and M. Balog, “AlphaEvolve: A coding agent for scientific and algorithmic discovery” (Google DeepMind, 2025; arXiv:2506.13131), and Google DeepMind’s announcement of 14 May 2025. The rank-⁠48 decomposition of the 4 × 4 product is the one published in google-⁠deepmind/alphaevolve\_results (CC BY 4.0); this page checks it with exact arithmetic (docs/plates/alphaevolve/computed.py). Strassen’s seven products after V. Strassen, “Gaussian elimination is not optimal” (Numerische Mathematik 13, 1969); 7 as the fewest after J. E. Hopcroft and L. R. Kerr (SIAM J. Appl. Math. 20, 1971) and M. Bläser’s survey (Theory of Computing, 2013); Winograd’s commutative method after R. P. Brent (Stanford, 1970); the tensor view and the 47 in arithmetic mod 2 after A. Fawzi et al. (Nature 610, 2022); the earlier complex 48 after I. E. Kaporin (Comput. Math. Math. Phys. 64, 2024); the rational 48 after J.-G. Dumas, C. Pernet and A. Sedoglavic (arXiv:2506.13242); best-⁠known counts after A. Sedoglavic’s fast matrix multiplication catalogue; costs in practice after J. Huang et al. (arXiv:1605.01078) and Y. Moran, O. Schwartz and S. Yuan (arXiv:2602.13171). The cube, the blocks, the record plate and the crystal are this page’s model of the arithmetic, not objects from any laboratory. Material presets and the model kit as on the site’s other model plates (public/looks/CREDITS.md).

## Licence CC BY-NC 4.0

The text, pictures and models on this page are licensed CC BY-NC 4.0: free to use and adapt for teaching and other non-commercial purposes, with credit to world.lapla.si. Third-party material listed above keeps its own licence.

https://creativecommons.org/licenses/by-nc/4.0/deed.en

## Cite this plate

Laplace’s Mini World, Plate F62, “AlphaEvolve: Fewer Multiplications”, https://world.lapla.si/en/alphaevolve/, CC BY-NC 4.0, updated 2026-11-04.