4.5.28 · D2Linear Algebra (Full)
Visual walkthrough — Matrix representation of linear transformations
Step 0 — The three words we will use forever
Before any symbols, three plain-language ideas. Each is a picture, not a formula.
In the picture: two ingredient arrows (blue) and (orange) lie on the plane. A third arrow (green) is drawn as a stretched-and-added copy: . The numbers and are its coordinates. Read them off the grid — that is all coordinates ever are.
Why start here? Every symbol below is either an arrow, an ingredient arrow, or a coordinate. If those three are solid, nothing later can surprise you. See Coordinate vectors and bases for the deeper story of why the numbers are unique.
Step 1 — The one rule, drawn
WHAT. We state the machine's single promise in a picture: mixing before or after gives the same answer.
WHY. This is the only property we will use. Everything — the whole matrix — falls out of it. So we must see it, not just read it.
PICTURE. Two routes, same destination:
- Top route: take and , mix them into first, then run through .
- Bottom route: run and through first to get and , then mix those with the same numbers and .
Both land on the identical arrow (red). In symbols, reading each piece:
= \underbrace{3\,T(b_1)}_{\text{same stretch, moved output}} + \underbrace{2\,T(b_2)}_{\text{same stretch, moved output}}.$$ The numbers $3$ and $2$ **pass straight through** the machine untouched. That is the whole secret: to know $T$ on *any* arrow, you only need to know it on the **ingredient arrows**. --- ## Step 2 — Test the machine on the ingredients only **WHAT.** We feed the machine *just* $b_1$, then *just* $b_2$, and record where each goes. **WHY.** Step 1 proved these two outputs contain *all* the information. Everything else is mixing — free, no new machine-work needed. ![[deepdives/dd-maths-4.5.28-d2-s03.png]] **PICTURE.** Left panel: $b_1$ goes in, arrow $T(b_1)$ comes out (blue → red). Right panel: $b_2$ goes in, $T(b_2)$ comes out (orange → red). We have run the machine exactly **twice**. For a machine on $n$ ingredient arrows, you run it exactly $n$ times — never more. $$T(b_1) = \text{some output arrow}, \qquad T(b_2) = \text{some output arrow}.$$ But an arrow floating in the plane isn't yet *numbers*. To store it, we must measure it against ingredient arrows too — that is the next step. --- ## Step 3 — Measure each output against the output ingredients **WHAT.** We express each output arrow $T(b_j)$ as a stretch-and-add of the **codomain** ingredient arrows $c_1, c_2$ (the ingredients of the *output* world $W$). **WHY.** A picture of an arrow can't be typed into a computer; a pair of numbers can. Numbers only exist *relative to a chosen set of ingredients*. So we pick ingredients $c_1, c_2$ for the output space and read the coordinates off them. ![[deepdives/dd-maths-4.5.28-d2-s04.png]] **PICTURE.** The red output $T(b_1)$ is decomposed onto the $c_1$ (blue) and $c_2$ (orange) grid: dashed guide-lines show it equals $a_{11}c_1 + a_{21}c_2$. Reading the guide-lines: $$T(b_1) = \underbrace{a_{11}}_{\text{how much }c_1}c_1 + \underbrace{a_{21}}_{\text{how much }c_2}c_2, \qquad T(b_2) = \underbrace{a_{12}}_{\text{how much }c_1}c_1 + \underbrace{a_{22}}_{\text{how much }c_2}c_2.$$ Reading the two-index name $a_{ij}$: the **first** number $i$ says *which output ingredient* $c_i$; the **second** number $j$ says *which input ingredient* $b_j$ we fed in. So $a_{21}$ = "amount of $c_2$ in the output when we fed in $b_1$." > [!mistake] Skipping this measurement when $c_1,c_2$ are the standard ingredients > When $c_1=(1,0)$, $c_2=(0,1)$, the output *already looks like* its coordinates, so people > skip Step 3. The moment the output ingredients are tilted (as in Example 3 of the parent), > the arrow and its coordinates differ — you **must** solve for the $a_{ij}$. Never merge > Steps 2 and 3 in your head. --- ## Step 4 — Stack the numbers into a table (the matrix is born) **WHAT.** We take the coordinate pairs from Step 3 and stand them up as **columns**. **WHY.** We want a layout so that "feed in $v$, read out $T(v)$" becomes pure arithmetic. The column layout is the one that makes that work (proven in Step 5). ![[deepdives/dd-maths-4.5.28-d2-s05.png]] **PICTURE.** Two coordinate pairs slide up to become two vertical columns of a grid: $$[T] = \left[\ \underbrace{\begin{array}{c} a_{11} \\ a_{21} \end{array}}_{\text{where }b_1\text{ went, in }c\text{'s}} \ \middle|\ \underbrace{\begin{array}{c} a_{12} \\ a_{22} \end{array}}_{\text{where }b_2\text{ went, in }c\text{'s}}\ \right].$$ Every column is one machine-test. Column $j$ = "where ingredient $b_j$ landed, written in output ingredients." The mnemonic from the parent — **"Columns Catch Outputs in $C$"** — is exactly this picture. > [!mistake] Laying the outputs down as rows > It feels natural (we read left-to-right), but rows give you the ==transpose==, a *different* > machine. The next step shows why columns, and only columns, reproduce $T$. --- ## Step 5 — Why table-times-list gives the answer **WHAT.** We feed a general arrow $v = x_1 b_1 + x_2 b_2$ (coordinates $x_1,x_2$) and show the table multiplies onto the list $(x_1,x_2)$ to give the output coordinates. **WHY.** This is the payoff — it turns "run the machine" into "do arithmetic with the table." ![[deepdives/dd-maths-4.5.28-d2-s06.png]] **PICTURE.** Follow the arrows: $x_1$ picks out column 1, $x_2$ picks out column 2, and they add. Term by term: $$T(v) = x_1\,T(b_1) + x_2\,T(b_2) = x_1(a_{11}c_1 + a_{21}c_2) + x_2(a_{12}c_1 + a_{22}c_2).$$ Now **gather by output ingredient** — collect all the $c_1$ pieces, then all the $c_2$ pieces: $$T(v) = \underbrace{(a_{11}x_1 + a_{12}x_2)}_{\text{coordinate of }c_1}\,c_1 + \underbrace{(a_{21}x_1 + a_{22}x_2)}_{\text{coordinate of }c_2}\,c_2.$$ The two brackets *are* the output coordinates — and each bracket is exactly a **row of the table times the list**. That is the rule "row dot column." So: > [!formula] The fundamental relationship, now earned > $$\boxed{\,[T(v)]_C = [T]_C^B\,[v]_B\,}$$ > Reading it: **left** = coordinates of the output arrow in the $C$-ingredients; **right** = > the table times the coordinate-list of the input in the $B$-ingredients. Nothing here was > assumed — every symbol was drawn first. Because we *chose* the column layout to make this happen, matrix multiplication for a [[Composition of linear maps|composition]] $T\circ S$ must equal the matrix product — same consistency requirement, one level up. --- ## Step 6 — Edge case: the zero machine and the "do-nothing" machine **WHAT.** We check the two degenerate machines so no scenario is left unseen. **WHY.** A rule you can't run on the simplest inputs is a rule you don't understand. ![[deepdives/dd-maths-4.5.28-d2-s07.png]] **PICTURE.** Left: the **zero machine** crushes every arrow to the origin. Testing the ingredients, $T(b_1)=0$ and $T(b_2)=0$, so *every* column is $\binom{0}{0}$: $$[T]_{\text{zero}} = \begin{pmatrix} 0 & 0 \\ 0 & 0 \end{pmatrix}.$$ Its [[Kernel and image|image]] is a single point and its [[Rank and nullity|rank]] is $0$ — the columns carry no directions. Right: the **identity machine** leaves every arrow untouched. Then $T(b_1)=b_1$ and $T(b_2)=b_2$, and (with the same ingredients in and out) each output *is* an ingredient, so its coordinates are $(1,0)$ and $(0,1)$: $$[T]_{\text{id}} = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}.$$ Same recipe, no exceptions: **run on ingredients, write outputs in output ingredients, stack as columns.** > [!mistake] Thinking the identity is *always* the identity matrix > Only if the **input and output ingredients match**. Feed the identity map but read its > outputs in a *different* set of ingredients and you get a [[Change of basis|change-of-basis]] > matrix instead — still built by this exact recipe. --- ## The one-picture summary ![[deepdives/dd-maths-4.5.28-d2-s08.png]] One diagram, whole derivation: ingredient arrows $b_1,b_2$ enter the machine $T$ → each output is measured against $c_1,c_2$ → the coordinate pairs stand up as columns → the finished table multiplies any input list to give the output list. That closed loop *is* the theorem. > [!recall]- Feynman retelling — say it to a friend > You have a magic machine that stretches and spins arrows, but you can't test it on every > arrow — there are infinitely many. Trick: every arrow is secretly a recipe of a few > "ingredient arrows," like *2 parts this plus 3 parts that*. And this machine is fair — it > respects recipes: mix first or run-first, same result. So you only ever run the machine on > the ingredients, once each, and jot down where each one lands. But "lands where" has to be > numbers, so you measure each landing spot against the *output* ingredients too. Stack those > number-pairs standing up, side by side — that column-table is the matrix. Now for *any* > arrow, you never touch the machine again: you look up its recipe, multiply the table by that > recipe-list, and out pops where it goes. The zero machine gives an all-zeros table; the > do-nothing machine gives the $1$s-on-the-diagonal table. Same recipe every time. That's the > entire idea of representing a transformation as a matrix. > [!recall] Two quick self-checks > Why exactly two machine-runs for a plane map? ::: There are two ingredient arrows; each column is one run, and the map is fixed by its action on the ingredients. > If the output ingredients are tilted, what extra work appears in Step 3? ::: You must *solve* $T(b_j)=a_{1j}c_1+a_{2j}c_2$ for the coordinates; the arrow no longer equals its own coordinates. > What layout makes table-times-list reproduce $T$, and why? ::: Columns — because collecting the output by ingredient makes each output coordinate a row-of-table dotted with the input list. --- ## Connections - [[Matrix representation of linear transformations]] — the parent result this page derives visually. - [[Coordinate vectors and bases]] — the meaning of the numbers in Step 0. - [[Change of basis]] — what happens to the table in Step 6 when in/out ingredients differ. - [[Composition of linear maps]] — the column layout forces matrix multiplication. - [[Rank and nullity]] — read off the columns of the finished table (Step 6). - [[Kernel and image]] — the zero machine's collapsed image. - [[Eigenvalues and diagonalization]] — choosing ingredients that make the table simplest.