Visual walkthrough — Matrix multiplication — conditions, process, non-commutativity

The parent note told you the rule: to multiply two matrices, you dot the rows of the first with the columns of the second. This page derives that rule from a single idea — matrices move arrows around — using nothing but pictures. By the end you will never have to memorise the rule again; you will be able to rebuild it.

We assume you can add arrows tip-to-tail and stretch them (that is Matrix addition and scalar multiplication). Nothing else.

---

Step 1 — What is an arrow, really? Two numbers on a grid

WHAT. Draw the flat plane. Pick two special little arrows: ${\vec{e}}_1$ points one unit right, ${\vec{e}}_2$ points one unit up. We call these the basis vectors — the two "measuring sticks" of the plane.

WHY. Every other arrow is just a recipe made from these two sticks. The arrow $\vec{x}=\left[\begin{array}{c}2\\ 3\end{array}\right]$ literally means "walk $2$ copies of ${\vec{e}}_1$, then $3$ copies of ${\vec{e}}_2$." So a column of two numbers is not mysterious — it is directions written in the language of ${\vec{e}}_1$ and ${\vec{e}}_2$.

PICTURE. Below, the red stick is ${\vec{e}}_1$, the teal stick is ${\vec{e}}_2$, and the plum arrow is $\vec{x}=2{\vec{e}}_1+3{\vec{e}}_2$. The dotted path shows the "2 right, 3 up" recipe.

---

Step 2 — A matrix is a machine that only tells you where the two sticks go

WHAT. A transformation is any rule that picks up every arrow and drops it somewhere new, but keeps the grid straight and evenly spaced (this is a linear transformation). Here is the magic fact we will lean on the whole page:

If you know where ${\vec{e}}_1$ lands and where ${\vec{e}}_2$ lands, you know where every arrow lands.

WHY. Because $\vec{x}=2{\vec{e}}_1+3{\vec{e}}_2$, and a linear machine doesn't scramble that recipe — it just replaces each old stick with its new landing spot:

$$T(\vec{x})=2\underset{\text{new right-stick}}{\underbrace{T({\vec{e}}_1)}}+3\underset{\text{new up-stick}}{\underbrace{T({\vec{e}}_2)}}.$$

Each term is annotated: the $2$ and $3$ are unchanged (they are $\vec{x}$'s own recipe), only the sticks got swapped for their images.

PICTURE. Left panel: original grid with ${\vec{e}}_1,{\vec{e}}_2$. Right panel: the tilted grid after the machine ran. The new landing spots of the sticks are the two columns of the matrix.

---

Step 3 — Multiplying a matrix by one arrow: the "combine the columns" rule

WHAT. Take the matrix $B$ (landing spots) and the arrow $\vec{x}=\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]$ (a recipe). To find $B\vec{x}$, use Step 2's fact:

$$B\vec{x}=x_1\underset{\text{where }{\vec{e}}_1\text{ went}}{\underbrace{\left[\begin{array}{c}{B}_{11}\\ B_{21}\end{array}\right]}}+x_2\underset{\text{where }{\vec{e}}_2\text{ went}}{\underbrace{\left[\begin{array}{c}{B}_{12}\\ B_{22}\end{array}\right]}}.$$

WHY this and not something else? We chose the definition of $B\vec{x}$ so that the machine "$B$" respects recipes. $x_1$ scales the first landing column, $x_2$ scales the second, and we tip-to-tail them. Now read the top row of that sum:

$$(B\vec{x}{)}_1=B_{11}{x}_1+B_{12}{x}_2.$$

That is exactly row 1 of $B$ dotted with $\vec{x}$. The row·column dot product wasn't invented — it fell out of "combine the columns."

PICTURE. The two landing columns get scaled (red column times $x_1$, teal column times $x_2$) and added tip-to-tail into the plum result $B\vec{x}$.

---

Step 4 — Two machines in a row: this is why $AB$ exists

WHAT. Now run two machines: first $B$, then $A$. Feed in $\vec{x}$, get $B\vec{x}$, then feed that into $A$ to get $A(B\vec{x})$. We want one matrix $C$ that does both at once: $C\vec{x}=A(B\vec{x})$. That single machine is defined to be $C=AB$.

WHY the order "$A$ after $B$" but written $AB$? Because we write functions on the left of their input: $A(B\vec{x})$ — the thing nearest $\vec{x}$ acts first. So $AB$ means "$B$ first, then $A$." This reading is the seed of non-commutativity: swapping to $BA$ swaps the order of the actions, and shoes-then-socks $\ne$ socks-then-shoes.

PICTURE. A three-panel pipeline: the input arrow → after $B$ (tilted grid) → after $A$ (tilted again). The dashed shortcut arrow across the whole pipeline is the single machine $C=AB$.

---

Step 5 — Build $C=AB$ column by column (the whole rule appears)

WHAT. By Step 2, we know $C$ completely once we know where $C$ sends ${\vec{e}}_1$ and ${\vec{e}}_2$. So push ${\vec{e}}_1$ through the pipeline:

$$C{\vec{e}}_1=A\left(B{\vec{e}}_1\right)=A\underset{\text{column 1 of }B}{\underbrace{\left[\begin{array}{c}{B}_{11}\\ B_{21}\end{array}\right]}}.$$

Column 1 of $C$ is just $A$ applied to column 1 of $B$. Same for ${\vec{e}}_2$ giving column 2. So:

Column $j$ of $AB$ = $A$ times column $j$ of $B$.

WHY. $B{\vec{e}}_1$ is literally column $1$ of $B$ (feed the first stick in, out comes its landing spot). Then Step 3 tells us $A$ applied to that column is a row·column dot product. Spelling out entry $(i,j)$ using Step 3's dot-product formula:

$$C_{ij}=\underset{\text{row }i\text{ of }A}{\underbrace{A_{i1}}}\underset{\text{col }j\text{ of }B}{\underbrace{B_{1j}}}+A_{i2}{B}_{2j}=\sum _k{A}_{ik}{B}_{kj}.$$

Every symbol earned: $A_{ik}$ walks along row $i$ of $A$, $B_{kj}$ walks down column $j$ of $B$, and $k$ is the shared index that lets them meet.

PICTURE. The final grid $C$ shown as: column 1 = $A$ acting on $B$'s column 1, column 2 = $A$ acting on $B$'s column 2. The $(1,1)$ entry is highlighted as row-1-of-$A$ meeting column-1-of-$B$.

---

Step 6 — Why the inner dimensions MUST match (the degenerate case)

WHAT. $B$'s columns are arrows living in some space of, say, $n$ numbers. To feed such an arrow into $A$, machine $A$ must expect $n$-number arrows — i.e. $A$ must have $n$ columns. If $A$ has a different number of columns, the pipe is broken.

WHY it fails. In ${\sum }_k{A}_{ik}{B}_{kj}$, the index $k$ has to run over the same range in both factors. If $A$ has $2$ columns ($k=1,2$) but $B$ has $3$ rows ($k=1,2,3$), the sum has terms with no partner — meaningless. That is exactly Example 3 in the parent: $A_{2\times 2}$ times $B_{3\times 1}$ is undefined.

PICTURE. Two connectors: a matching plug ($A$'s $n$ columns fit $B$'s $n$ rows, they click) and a mismatched plug ($2$-prong socket, $3$-prong plug — physically won't seat).

---

Step 7 — Watch order actually break things (non-commutativity, geometrically)

WHAT. Let $A$ be a $90^{\circ }$ rotation and $B$ a horizontal stretch. Do $B$ then $A$ ($AB$) and $A$ then $B$ ($BA$) on the same little L-shape.

WHY they differ. Rotating a wide shape lands it tall, then stretching widens the tall one. Stretching first widens it, then rotating makes it tall-and-fat differently. Different final shapes ⟹ different matrices ⟹ $AB\ne BA$. The numbers agree: with $A=\left[\begin{array}{cc}1& 2\\ 3& 4\end{array}\right]$, $B=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]$ (parent Example 2), $AB=\left[\begin{array}{cc}2& 1\\ 4& 3\end{array}\right]$ but $BA=\left[\begin{array}{cc}3& 4\\ 1& 2\end{array}\right]$.

PICTURE. Two side-by-side pipelines starting from the same L, ending on visibly different L's.

---

The one-picture summary

Everything on this page is one sentence with a picture: a matrix stores where the basis sticks land; stacking two matrices means "land, then land again," and reading that off column-by-column forces the row·column sum.

Recall Feynman retelling (say it to a 12-year-old)

Picture two little arrows, one pointing right and one up — these are your rulers. Any arrow you draw is just "so many rights, so many ups." A matrix is a cheat-sheet: it only tells you where those two rulers get moved to; from that you can figure out where anything moves, because every arrow copies the rulers' motion.

Now suppose you run two moving-machines back to back — machine $B$ first, machine $A$ second. You'd love a single combined machine. To build it, just ask: "where does the right-ruler end up after both machines? where does the up-ruler end up?" Those two answers, side by side, are the combined machine $AB$. When you work out one number of it, you end up walking across a row of $A$ and down a column of $B$, multiplying pairs and adding — that's the famous rule, and now you see it wasn't handed down, it was forced.

Two loose ends: the rulers coming out of $B$ have to be exactly the size machine $A$ knows how to eat, which is why the inner dimensions must match — otherwise the machines don't plug together. And running $B$-then-$A$ is a different journey than $A$-then-$B$, just like putting on socks then shoes is not shoes then socks — which is why $AB$ and $BA$ usually disagree.

Recall

Column $j$ of $AB$ equals what? ::: $A$ applied to column $j$ of $B$. Why is $C_{ij}={\sum }_k{A}_{ik}{B}_{kj}$ forced (not chosen)? ::: Because we demand $C\vec{x}=A(B\vec{x})$; the sum is what "combine $B$'s columns, then run $A$" produces. Why must $A$'s columns equal $B$'s rows? ::: The shared index $k$ must run over the same range in both factors, else terms have no partner. Geometrically, why $AB\ne BA$? ::: They apply the two motions in opposite orders, and order of transformations changes the outcome.

---

Connections

• Matrix multiplication — conditions, process, non-commutativity — the parent rule this page derives
• Linear transformations — the "moving machine" picture used throughout
• Matrix addition and scalar multiplication — scaling and tip-to-tail adding of columns (Steps 1, 3)
• Identity matrix — the machine that leaves both rulers where they are
• Inverse of a matrix — the machine that undoes another's motion
• Matrix transpose properties — $(AB{)}^T=B^T{A}^T$, order reverses just like the pipeline
• System of linear equations — reading $A\vec{x}=\vec{b}$ as "which recipe $\vec{x}$ lands on $\vec{b}$"