Linear algebra is usually taught twice, and, with a regularity that ought to embarrass the profession, badly on both occasions. The first time it arrives as a recipe: here is a grid of numbers, here is how to push the numbers about, and here, at the bottom of the page, is the answer, which you will be asked to reproduce on Thursday. The second time it arrives as an abstraction: a vector space is a set equipped with two operations satisfying eight axioms, and the grid of numbers, which was the whole of the first course, is now dismissed as a mere “representation”. The curious student who survives both courses is entitled to suspect that the recipe and the abstraction are two different subjects, and that the second was invented to make the first look vulgar. This book is an extended argument that the suspicion is mistaken: the recipe and the abstraction are a single subject seen from two sides, and the whole art of understanding it lies in being able to walk, without vertigo, from one side to the other. Whoever has opened this book is therefore asked to accept a particular method, and it is only fair to state it before the first chapter rather than after. Every idea is met three times. It is met first as mathematics, derived from a stated definition by an argument that a patient hand can follow with pencil and paper, so that nothing falls from the sky and no formula is asked to be believed merely because it is printed. It is met second as an algorithm: the derivation is converted, step by step and without cleverness, into a procedure that a machine, or a diligent person with a scientific calculator, could execute. And it is met third as software, where the procedure we have just built is set beside the professional routine that Python’s numerical libraries supply, so that we may ask the two uncomfortable questions that every honest computation owes its author: do they agree, and, where they disagree, which of them is wrong? The order is deliberate. A library call such as np.linalg.solve is a splendid instrument, but an instrument used before its principle is understood is merely a superstition with a good user interface. Why Python, then, and why not a more austere vehicle? The sceptic is right to press the point, since a language is not neutral and a book that adopts one has taken sides. The case is, first, that Python’s numerical libraries are the working environment of a very large proportion of the people who actually use linear algebra today, in laboratories, in hospitals, in banks and in the firms that train neural networks; a student who learns the subject there learns it where it is practised. The case is, second, that the language reads, to a surprising degree, like the mathematics it describes, so that a short program is often a legible restatement of the theorem it illustrates and not a translation into a foreign tongue. The case against, which the dialectical temperament will wish to hear stated plainly, is that a tool this convenient tempts its user to stop thinking at precisely the moment when thought is most needed. A great deal of the later chapters is accordingly devoted to what the libraries conceal: the cost of an algorithm, the error it commits, and the circumstances in which a perfectly correct formula, executed on a perfectly healthy machine, returns nonsense. The book is addressed to anyone who has met elementary algebra and is willing to meet it again with more attention: the undergraduate in science or engineering, the graduate student who has been using matrices for a year without quite being introduced to them, the data analyst who wishes to know what the software is doing under the hood, and the physician or economist who has noticed that the papers of their own discipline have lately begun to be written in a dialect of eigenvalues. No prior knowledge of Python is assumed. Read more
