Chapter 10 — Further Reading

An annotated map to where LU and PLU live in the standard texts and the best free resources. LU sits at the seam between algebra (the factorization and its uniqueness) and numerical computing (pivoting, stability, operation counts), so the references split that way: Strang and Boyd–Vandenberghe for the structural and applied view, Trefethen–Bau for the rigorous numerical story. You need none of these to follow the chapter; reach for them when you want a second voice or more depth on stability.

The companion textbooks

  • Gilbert Strang, Introduction to Linear Algebra (Wellesley–Cambridge Press), Chapter 2 (§2.6–2.7). The closest match to this chapter's spirit and the place to read next. Strang introduces $A=LU$ as the natural record of elimination, derives it from the elementary-matrix viewpoint exactly as our §10.3 does, and is emphatic about the factor-once / triangular-solve efficiency and the "$L$ holds the multipliers" reading. His treatment of $PA=LU$ and why permutations enter is the canonical undergraduate account. Best fit for: anyone who wants the algebra and the computation together, with the elimination-as-factorization link made vivid.

  • Stephen Boyd & Lieven Vandenberghe, Introduction to Applied Linear Algebra (Cambridge; free PDF at vmls-book.stanford.edu), the chapters on matrices and linear equations. The applied, cost-aware counterpart. They frame solving $A\mathbf{x}=\mathbf{b}$ around the factor-once-reuse-many idea and the operation counts of §10.8, and they hammer the "don't compute the inverse" rule as hard as we do. Pairs naturally with the two case studies and the from-scratch toolkit. Best fit for: CS / data-science / finance readers who care about how this runs at scale.

  • David C. Lay, Steven Lay & Judi McDonald, Linear Algebra and Its Applications (Pearson), Section 2.5 ("Matrix Factorizations"). A careful, example-rich first pass at the LU factorization and its use for multiple right-hand sides, with the algorithm laid out in meticulous, slow detail. If any hand factorization in this chapter felt fast, Lay slows it down. Best fit for: readers who want maximum worked detail on building $L$ and $U$ and solving with them.

Numerical and computational depth

  • Lloyd N. Trefethen & David Bau III, Numerical Linear Algebra (SIAM), Lectures 20–23. The definitive rigorous account of LU as a numerical algorithm, and the natural companion to our Chapter 38. Lecture 20 develops Gaussian elimination as $LU$ factorization and counts operations ($\tfrac23 n^3$); Lecture 21 explains pivoting and exactly why partial pivoting is needed for stability (the existence-vs-accuracy distinction of our §10.7); Lectures 22–23 give the stability analysis, including the (rare, instructive) worst-case where even partial pivoting can grow errors. The honest, expert treatment of when LU is safe and when it strains. Best fit for: readers heading toward scientific computing; read after the chapter to see the algorithm's numerical soul.

  • Gene H. Golub & Charles F. Van Loan, Matrix Computations (Johns Hopkins), Chapter 3 ("General Linear Systems"). The encyclopedic reference. Covers LU with partial and complete pivoting, the in-place storage scheme our §10.9 mentions, block algorithms for cache efficiency, and error bounds — far more than the chapter needs, but the place to look up any detail. Best fit for: graduate study or implementing a serious solver.

  • William H. Press et al., Numerical Recipes, the chapter on "Solution of Linear Algebraic Equations" (LU decomposition section). A pragmatic, code-first account of LU with partial pivoting and how to reuse the factors for multiple right-hand sides — useful background for fleshing out your toolkit/lu.py.

Free and open resources

  • ★ 3Blue1Brown (Grant Sanderson), Essence of Linear Algebra. No episode is titled "LU," but "Inverse matrices, column space and null space" gives the geometric intuition for solving $A\mathbf{x}=\mathbf{b}$ and for why undoing a transformation (the inverse) is a different, costlier object than solving one system — the geometric backdrop to §10.8's "never invert." Best fit for: building the picture before the algebra.

  • MIT OpenCourseWare 18.06, Linear Algebra (Gilbert Strang), Lecture 4 ("Factorization into A = LU"). Free video of Strang deriving the LU factorization at the board, including the elementary-matrix argument and why the multipliers assemble into $L$ — the ideal companion to our §10.3–10.4. Search "MIT 18.06 LU factorization."

  • scipy.linalg documentation — lu, lu_factor, lu_solve, solve_triangular. The production interface for everything in this chapter. The docs make explicit scipy's convention ($A = P L U$, with $P$ on the left) and show how lu_factor/lu_solve pack the factors for reuse — exactly the factor-once-reuse-many pattern. Read these alongside the toolkit exercise so your from-scratch plu matches scipy's behavior (modulo pivoting choices).

  • numpy.linalg.solve documentation and source notes. Worth reading to confirm that numpy does not form the inverse — it calls LAPACK's gesv, a PLU solve — which is the practical backing for the chapter's "never invert" rule.

On the algorithm's history

  • Joseph F. Grcar, "Mathematicians of Gaussian Elimination," Notices of the AMS 58 (2011), 782–792, and the MacTutor History of Mathematics Archive (mathshistory.st-andrews.ac.uk). Background for the chapter's [verify]-flagged history: the ancient elimination (Gauss, the Chinese Nine Chapters) versus the twentieth-century insight — Alan Turing's 1948 Rounding-off Errors in Matrix Processes and James Wilkinson's error analysis — that the elimination should be kept as a reusable factorization and analyzed for floating-point stability. The honest version of who did what, and a good model for treating attribution with care.

How to read alongside this book

If you are a CS / data-science / finance reader: do the from-scratch coding exercises (10.20–10.22), keep Boyd–Vandenberghe open for the cost themes, work the factor-once-reuse timing experiments (10.24–10.25), and skim Trefethen–Bau Lecture 20. If you are a math major: prove uniqueness and the elementary-matrix facts (10.17–10.19, 10.23), then read Strang §2.6–2.7 and Trefethen–Bau Lecture 21 for the pivoting theory. If you are in physics / engineering: lean on the circuit-simulation case study, connect it to the finite-element solvers in your other courses, and read Lay §2.5 for the slow, worked version. Everyone should watch the MIT 18.06 LU lecture — twenty minutes that make $A=LU$ feel inevitable — and remember the chapter's rule on the way out: to solve, factor and substitute; never invert.