# How Fast Can You Multiply Matrices?

### Conventional knowledge says 8 multiplications, but is that true? Read on to get one data experts view, and some Python code to help answer the question.

Join the DZone community and get the full member experience.

Join For FreeSuppose you want to multiply two 2 × 2 matrices together. How many multiplication operations does it take? Apparently 8, and yet in 1969 Volker Strassen discovered that he could do it with 7 multiplications.

## Upper and Lower Bounds

The obvious way to multiply two *n* × *n* matrices takes *n*³ operations: each entry in the product is the inner product of a row from the first matrix and a column from the second matrix. That amounts to *n*² inner products, each requiring *n* multiplications.

You can multiply two square matrices with O(*n*³) operations with the method described above, and it must take at least O(*n*²) operations because the product depends on all of the 2 *n*² entries of the two matrices. Strassen's result suggests that the optimal algorithm for multiplying matrices takes O(*n*) operations for some *k* between 2 and 3. By applying Strassen's algorithm recursively to larger matrices you can get *k* = log _{2} 7 = 2.807.

The best known value at the moment is *k* = 2.3728639.

## Bounds on Bounds

Recently, the blog Gödel's Lost Letter and P = NP posted an article Limits on Matrix Multiplication where they report on recent developments for finding the smallest value of *k*. A new paper doesn't report a new value of *k*, but a limit on what current *approaches* to the problem can prove. Maybe *k* can equal 2, but there is a lower bound, strictly bigger than 2, on how small current approaches can go.

## Is This Practical?

When I first heard of Strassen's method, I was told it's a curious but impractical result. Strassen saved one multiplication at the expense of introducing several more addition operations.

According to the Wikipedia article on matrix multiplication, recursively applying Strassen's method can save time for *n* > 100. But there's more to consider than counting operations. Strassen's method, and subsequent algorithms, are more complicated. They may not be more efficient in practice even if they use fewer operations because the operations may not vectorize well.

Wikipedia reports that Strassen's algorithm is not as numerically stable as the traditional approach, but this doesn't matter when working over finite fields where arithmetic is exact.

## Strassen's Method

Let's look at just what Strassen's method does. We want to find the product of two matrices:

I started to spell out Strassen's method in LaTeX equations, but I thought it would be much better to write it out in code so I can be sure that I didn't make a mistake.

The following Python code randomly fills in the values of the a's and b's, computes the c's using the conventional method, then asserts that you can find these values from the q's computed from Strassen's method. Note there is one multiplication in each of the seven q's.

```
from random import randint
# Fill matrices with random integer values
a11 = randint(0, 9)
a12 = randint(0, 9)
a21 = randint(0, 9)
a22 = randint(0, 9)
b11 = randint(0, 9)
b12 = randint(0, 9)
b21 = randint(0, 9)
b22 = randint(0, 9)
# Traditional matrix multiplication
c11 = a11*b11 + a12*b21
c12 = a11*b12 + a12*b22
c21 = a21*b11 + a22*b21
c22 = a21*b12 + a22*b22
# Strassen's method
q1 = (a11 + a22)*(b11 + b22)
q2 = (a21 + a22)*b11
q3 = a11*(b12 - b22)
q4 = a22 * (-b11 + b21)
q5 = (a11 + a12)*b22
q6 = (-a11 + a21)*(b11 + b12)
q7 = (a12 - a22)*(b21 + b22)
assert(c11 == q1 + q4 - q5 + q7)
assert(c21 == q2 + q4)
assert(c12 == q3 + q5)
assert(c22 == q1 + q3 - q2 + q6)
```

Since Strassen's method takes *more* operations than the traditional method for multiplying 2 × 2 matrices, how can it take *fewer* operations than the traditional method for multiplying large matrices?

When you apply Strassen's method to a matrix partitioned into submatrices, its multiplications become *matrix* multiplications, and its additions become *matrix* additions. These operations are O( *n*^{2.807}) and O( *n*^{2}) respectively, so saving multiplications at the cost of more additions is a win.

Published at DZone with permission of John Cook, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

Comments