I've just been tasked with doing this for homework, and I thought I had a neat epiphany: Strassen's algorithm sacrifices the "breadth" of its pre-summation components in order to use less operations in exchange for "deeper" pre-summation components that can still be used to extract the final answer. (This isn't the best way to say it, but it's hard for me to explain it).
I'm going to use the example of multiplying two complex numbers together to illustrate the balance of "operations vs. components":
Notice that we use 4 multiplications, which result in 4 product components:
Note that the 2 final components we want: the real and the imaginary parts of the complex number, are actually linear equations: they are sums of scaled products. So we are dealing with two operations here: addition and multiplication.
The fact is that our 4 product components can represent our 2 final components if we simply add or subtract our components:
But, our final 2 components can be represented as sums of products. Here's what I came up with:
If you can see, we actually only need 3 distinct product components to make our final two:
But wait! Each of the capital letters are in themselves products! But the catch is that we know we can generate (A+B+C+D) from (a+b)(c+d), which is only 1 multiplication.
So in the end, our algorithm is optimized to use less, but "fatter" components, where we trade the amount of multiplications for more summing operation.
Part of what enables this is the distributive property, which allows A(B+C) to be equivalent to (AB+AC). Notice how the first can be computed using 1 add and 1 multiply operation, while the second requires 2 multiplies and 1 sum.
Strassen's algorithm is an extension of the optimization we applied to complex number products, except there are more target product terms and possible more product components we can use to get those terms. For a 2x2 matrix, Strassen's algorithm morphs an algorithm that needs 8 multiplications to one that needs 7 multiplications, and leverages the distributive property to "merge" two multiplications into one operation, and instead takes away from the new "fatter" node to extract one product term or the other, etc.
A good example: to get (-1) and (2) and (5), you can think about it as just (-1), (2), (5), or you can think about it as (2-3), (2), (2+3). The second operations use less distinct numbers, though. The catch is that the number of distinct numbers is equivalent to the number of product components you need to compute for matrix multiplication. We simply optimize for this to find a certain view of the underlying operations that leverages isomorphic outputs using a different variation through the distributive property.
Perhaps this could be linked to topology in some way? This is just my layman's way of understanding it.
Edit: Here is a picture of my notes I drew in the process of making the complex number explanation: