Part II — Matrices as Transformations

Here is the most important sentence in the book, and Part II is where it stops being a slogan and starts being something you can see: a matrix is a function that transforms space. Not a grid of numbers to be memorized, not a bookkeeping device for systems of equations — a verb. When you multiply a vector by a matrix $A$, you take the whole plane (or all of $\mathbb{R}^n$) and stretch it, rotate it, shear it, flatten it, or flip it. Everything in this part flows from that single reframing, and once it clicks, half of linear algebra stops being arbitrary.

The motivating question is geometric: what are all the ways you can move space around so that grid lines stay straight, parallel, and evenly spaced, and the origin stays put? That constraint — straight lines stay straight — is exactly what "linear" means, and it turns out every such transformation is captured by a matrix. The deep payoff is that you only need to know where the basis vectors go. Track the images of $\mathbf{e}_1$ and $\mathbf{e}_2$, write them as the columns of $A$, and you have completely determined what $A$ does to every vector in the space.

Chapter 7, Matrices as Functions, is the heart of this part: it establishes the columns-as-images-of-basis-vectors picture and pulls our recurring 2D visualizer front and center, so you can literally watch the unit square deform under different matrices. Chapter 8, Matrix Operations, then defines addition and — crucially — multiplication as composition: $AB$ means "do $B$, then do $A$," which is why the row-times-column rule looks the way it does and why matrix multiplication does not commute ($AB \ne BA$ in general). You'll also meet the transpose $A^{\mathsf{T}}$, which we'll give deeper geometric meaning in later parts. Chapter 9, The Inverse Matrix, asks the natural follow-up: if a matrix is a transformation, can you undo it? Sometimes — and $A^{-1}$ exists exactly when the transformation loses no information, never collapsing space onto a lower-dimensional shadow. Singular matrices are precisely the ones that flatten and cannot be reversed.

Chapter 10, LU and PLU Decomposition, offers your first taste of a recurring big idea — that factoring a matrix reveals structure. Writing $A$ as a product of simpler triangular pieces (with pivoting for stability) is how real software actually solves systems, far more efficiently than computing an inverse. Chapter 11, The Determinant, gives a single number a vivid geometric meaning: $\det(A)$ is the signed area or volume scaling factor of the transformation. This is where the visualizer's det annotation finally pays off — $\det(A) = 0$ means space got flattened, which is exactly why a zero determinant signals a singular, non-invertible matrix. Finally, Chapter 12, Application: Computer Graphics, cashes everything in: homogeneous coordinates, rotation/scaling/translation as matrix multiplication, and the rendering pipeline that puts a moving 3D world on your screen. Every video game and animation you have ever seen is matrices transforming space, frame after frame.

The style-bible themes deepen here. Transformations are the point — row reduction and determinants are tools in service of understanding transformations, never the destination. And geometry and algebra are one object: the determinant is simultaneously a messy cofactor sum and a clean statement about volume; matrix multiplication is simultaneously a triple-loop arithmetic rule and the simple act of composing two motions.

Be warned about one genuinely counterintuitive fact in this part: matrix multiplication is not commutative. Rotating then shearing is not the same as shearing then rotating, and the visualizer will show you exactly why — the order in which you transform space matters, just as the order of putting on socks and shoes matters. If you ever catch yourself assuming $AB = BA$, stop and picture the two transformations applied in sequence.

By the end of Part II you will be able to: read any matrix as a transformation by inspecting where it sends the basis vectors; multiply matrices and explain the result as composition rather than a memorized rule; determine whether a transformation is invertible and compute its inverse when it is; factor a matrix via LU/PLU and explain why that beats inversion for solving systems; compute and interpret a determinant as a volume-scaling factor; and build the graphics transformations behind 2D and 3D rendering. Your toolkit gains matrices.py, inverse.py, lu.py, and determinant.py, each verified against numpy.

With matrices now understood as transformations, a sharper question comes into focus: given a transformation, what can it reach, and what does it destroy? That is the doorway to Part III and the four fundamental subspaces — the structural skeleton that organizes the rest of the book.

Chapters in This Part