How to use this book

On this page

Reading paths by goal
Identifiers and links
The core route and the evidence to advance
How to work through a topic
Your first week: one mathematics priority and one computing priority
Score your work on five dimensions
Retention, and AI without surrendering the work

This book has more than one entrance. You do not need every chapter, and few readers should read it in page order. Choose the reading path below that matches your goal, take the diagnostics in Part I to find where on that path to start, and move on when the evidence says so: an unseen problem solved without help, not a page count.

On any path, the first task is to become reliable at a small chain of ideas rather than to absorb the whole curriculum at once. A function has an input slot. A program has a state. A derivative measures local change. A proof states exactly which cases its conclusion covers. Every later system in this book depends on being able to identify those objects rather than just recognize their notation.

Reading paths by goal#

Each path names parts, by Roman numeral, and chapters in the order to study them; the next section explains the identifiers. On every path, first repair whatever the diagnostics flag in Modules 01–04 and C01–C05. “Alongside” marks work that runs in parallel, in its own sessions. Every chapter opens with its prerequisites, so you can check a jump before you make it, and the planner in Part I, “Plan your path”, fits two or three paths into one week.

Goal	Path, in order
A calculus student	I: LM, diagnostic D $\to$ II: the parts of Modules 01–04 that D’s repair map names $\to$ III: Modules 05–08, W01, R1, then 09–19 and assessment CI $\to$ V: Modules 20–25, R2, then 26–32 and CII $\to$ VI: Modules 33–38, R3, then 39–46 and CIII. Alongside: the course coverage map in Part I, to match your syllabus; C01–C02 for code beside the mathematics. After Module 11, AI01 or EL01 puts the chain rule to work; F01 does after Module 12.
A computer-science student	I: LM, diagnostics CD and D, the course coverage map $\to$ II: C01–C05 with Modules 01–04 beside them, checkpoint CP $\to$ IV: C06–C08, W02, CA; C09–C10, W03; C11–C16, W07; C17, CS $\to$ VII: A01–A04 $\to$ VIII: J01–J03 $\to$ IX: GD, then G01–G03 and the units your interests need. Alongside: Calculus I–III (Parts III, V, and VI) at your program’s pace, and the Algorithms Lane (XIV: CP00, CP01) once C03 has given you basic C++.
A software engineer moving into AI and machine learning	I: LM, diagnostics CD and D $\to$ III: Modules 05–11 $\to$ XI: AI00, then AI01, an autograd engine you write yourself $\to$ III: Modules 12–17 $\to$ V: Module 25, then 31–32 (parametric and polar curves) $\to$ VI: Modules 33–38 $\to$ VII: A01–A04, W04, A05–A06, then T03, with C14 first if testing and measurement are new to you $\to$ IX: G04–G05, G12–G14, GP2. Alongside: X: F19, performance on parallel hardware, after C08–C09 if trees and caches are new to you; the evidence chapter at the end of Part IX, once you have a project to show.
A hardware, robotics, or aerospace engineer	I: LM, diagnostic D $\to$ III: Modules 05–11 $\to$ XII: EL00, then EL01, why a drone hovers $\to$ III: Modules 12–19, with X: F00 and F01 (feedback control) after Module 12 $\to$ V: Modules 20–25, then 31–32 (parametric and polar curves) $\to$ VI: Modules 33–46 $\to$ VII: A01–A03, A05–A06, W05, T04, T05 $\to$ VIII: J04. Alongside: C01–C02 from the start, because the labs use Python; then C03, C09–C10, and C14 before T04 and J04.
Preparing for coding interviews	I: LM (its section I covers AI use in interviews), diagnostic CD $\to$ II: C01–C05, checkpoint CP $\to$ IV: C06–C08, W02, CA $\to$ XIV: CP00, which maps the whole lane, and CP01 $\to$ IV: C09–C14 and C16–C17 for systems questions $\to$ VIII: J02 $\to$ X: F19 $\to$ IX: G01 and G03, then G04 and G07–G09 for system design, and the evidence chapter. Alongside: once you start the lane, keep its two to five short sessions a week.
A mathematics enthusiast who wants proof and geometry	I: LM, diagnostic D $\to$ XIII: GEO00, then GEO01, whose own diagnostic places you $\to$ II: C01–C05, ending with logic, proof, induction, and counting $\to$ III: Modules 05–19, reading 06–07 and 13 for the precise arguments $\to$ VII: A01–A02 $\to$ V: Modules 20–32, with 26–30 on convergence $\to$ VI: Modules 33–46, ending with the integral theorems $\to$ IV: C06–C09, C15–C16, W07, computability and the limits of proof $\to$ IX: G01–G03. Alongside: W02, where invariants become algorithms, after C08.

The parts are I Start here, II Foundations, III Calculus I, IV Algorithms and systems, V Calculus II, VI Calculus III, VII Applied mathematics and computation, VIII Projects, IX The graduate core, X Frontier engineering, XI The AI Lab, XII The Engineering Lab, XIII Geometry, and XIV The Algorithms Lane. Paths combine: a student who wants both calculus and AI runs the first and third rows side by side, and the planner shows how many hours a week that takes.

Identifiers and links#

Every module and unit has a stable identifier, and each of its exercises adds a number to it: M12.09 is an exercise in Module 12. The text calls the mathematics modules “Module 01” to “Module 46”; their exercise identifiers and the route table below use the prefix M.

Identifier	What it marks	Example
M01–M46	Mathematics modules: foundations (01–04) and Calculus I–III (05–46).	M12.09
C01–C17	Computing units: programming, proof, discrete mathematics, algorithms, and systems.	C07.04
A01–A06	Applied mathematics: linear algebra, probability, statistics, numerical methods, and differential equations.	A02.03
T01–T05	Specializations: performance, GPUs and graphics, machine learning, embedded and robotics software, and scientific computing.	T03.02
J01–J05	Projects. Each project counts as one exercise.	J02
W01–W08	Workshops that join two subjects at their seam.	W04.01
G01–G16, GP1–GP2	The graduate core: sixteen units and two capstone projects.	G13.02
D, CD, GD	Diagnostics: mathematics, computing, and graduate readiness.	D.14
R1–R3	Mixed reviews inside the calculus parts.	R1.05
CI–CIII; CP, CA, CS; GA, GB	Cumulative assessments: Calculus I–III; the programming, algorithms, and systems checkpoints; the two graduate assessments.	CII.09
LM	The chapter on how to learn.	LM.04
F00, F01, F19	Frontier engineering. F00 maps the whole route; this book contains F01 and F19 from it.	F01.11
AI, EL, GEO, CP with two digits	Modules of the AI Lab, the Engineering Lab, Geometry, and the Algorithms Lane. Module 00 is each track’s route map.	AI01.13

The two-digit module number separates the Algorithms Lane (CP01.04) from the programming checkpoint (CP.04). A diagnostic inside a module adds a D, as in GEO01.D03.

How the links work. In the electronic edition every exercise identifier is a link: click it to jump to the complete solution, and click the identifier above the solution to come back. Where running text links an identifier, as with M08.02 here, the link goes to the exercise itself. In print, each chapter’s solutions come after its whole problem set, in the same order and under the same identifiers; most chapters gather them under the heading “Complete solutions”. Hints, where a chapter gives them, come after the problems and before the solutions; some modules give a ladder of up to three rungs, so you can take one rung at a time. Worked examples, subparts, and repeated attempts are not counted as separate exercises. Labs ship with starter files and tests in the companion code at bezhig.com/book, and each lab names its folder.

The workshops. The eight workshops sit at the seams between subjects. W01 links substitution, function values, derivatives, and executable contracts. W02 connects induction, dynamic programming, graphs, and complexity. W03 connects source-level ownership to memory and hardware models. W04 derives automatic differentiation from algebra and uses gradients as geometric objects. W05 connects differential equations to stable, testable simulation. W06 connects linear algebra to graphics and spatial interpolation. W07 connects finite models to decidability and explains why their guarantees cannot be generalized carelessly. W08 asks you to defend a whole engineering result rather than a collection of isolated answers.

The core route and the evidence to advance#

Under the reading paths runs one core route in six stages. Advance when you can produce the evidence in the right-hand column on fresh problems, not when you have read the pages. The frontier tracks, Parts X–XIV, branch off this route wherever their prerequisites are met, as the paths above show.

Stage	Read and connect	Evidence before advancing
1. Inputs and state	M01–M04; C01–C05. Functions, algebra, state, logic, induction.	Substitute entire expressions; trace loops; explain an implication and construct a counterexample.
2. Change and proof	M05–M19; W01; R1; Calculus I assessment.	Derive a rate, take a justified limit, distinguish point from slope, set up an integral with units.
3. Algorithms and machines	C06–C17; W02, W03, W07; CP/CA/CS.	Prove an invariant; choose a representation; account for lifetimes; explain a transaction and a failure trace.
4. Mathematical models	M20–M46; A01–A06; W04–W05.	Select an integration or convergence method, use gradients, solve a projection problem, check numerical error separately from model error.
5. Specialized engineering	T01–T05; W06; J01–J05.	Complete bounded projects with independent tests, correctness reasoning, measurements, and stated limitations.
6. Advanced practice	GD; G01–G16; GP1/GP2; GA/GB; W08.	Defend semantic preservation, numerical assumptions, data separation, fault handling, and a reproducible technical investigation.

A row is a learning stage, not an academic semester or a promised duration. C01–C05 can run in parallel with M01–M04. Someone who already demonstrates programming competence may move quickly there while spending much longer on functions. Conversely, understanding calculus does not waive memory ownership or operating-system prerequisites. After each stage, reserve an unopened assessment for a later day.

How to work through a topic#

The three passes. First, identify the object, the question, and the assumptions. Read the explanation and reconstruct one worked example. Second, close the example and attempt the independent set. Write the method before calculation or code. Third, compare against the solutions, identify the first unjustified step, and solve a different problem later. A corrected copy belongs in your notes; an unseen successful attempt is the evidence needed to advance.

What counts as knowing a subject. Exposure means recognizing the terms. Guided performance means carrying out a familiar method with help. Independent operational competence means choosing a method on a fresh bounded problem, explaining its assumptions, implementing or proving it, and checking a changed case. Advanced specialization adds unfamiliar scale, constraints, and sustained design work. Research adds a meaningful question, a fair comparison to prior work, and new defensible evidence. These are different achievements; this book supplies exercises and exemplars for building the evidence rather than awarding a title to its reader.

The standard throughout is explicit reasoning, useful practice, and honest correction. The theory here is established through definitions, derivations, proof arguments, execution traces, and counterexamples. A finite test suite can reveal an error but cannot certify every theorem or possible execution. The verification chapter at the back of the book states the actual checks and the remaining boundaries.

Four threads to keep connected.

Representation: an expression, a function, a matrix, a program state, a memory layout, or a probability model. Ask what the symbols denote, their types or units, and which operations are allowed.
Reasoning: a substitution, invariant, inductive proof, residual, or theorem hypothesis. Ask why the method applies and what would make it fail. A useful counterexample is often more informative than a second easy success.
Implementation: an exact specification converted to bounded machine arithmetic, data structures, and control flow. Ask which mathematical assumptions the machine does not supply automatically.
Evidence: an independent calculation, proof, test oracle, convergence study, or controlled measurement. Ask which claim the evidence supports and which it leaves open. A fast incorrect computation is not a performance improvement; a plausible animation is not a validated simulation.

Your first week: one mathematics priority and one computing priority#

Run two lines at once, one mathematics priority and one computing priority, with a little retrieval in every session. Choose a lower-load session of roughly 30–45 minutes or a standard session of roughly 60–90 minutes. These are adjustable planning choices, not a universal optimum. In a short session, use about five minutes for retrieval, ten for focused reading, fifteen to twenty for unaided work, then record the first error. In a longer session, deepen independent work and checking rather than adding unrelated subjects.

The table is a first week for a reader starting at the beginning of Parts II and III: Modules 01–08 are the mathematics priority, and C01 with the computing diagnostic is the computing priority. If your path or the diagnostics start you elsewhere, keep the same shape and substitute your path’s first chapters.

Day	Read	Attempt without help, then record
1	M02, up to its practice set; computing diagnostic	M02.01 and M02.02; CD.01. Explain what enters a function and how a loop changes state. Standard session: add M02.03.
2	M01, up to its practice set; C01 opening	M01.02 and M01.03; CD.02. Retrieve a whole-expression substitution. Locate the first illegal cancellation or sign change.
3	M05, up to its practice set	M05.01 and M05.02; C01.01. Name numerator and denominator changes and their units. Standard: begin C01.05.
4	M06, up to its practice set	M06.01 and M06.04; C01.03. Explain why the input difference is nonzero before a limit is taken.
5	M08, up to its practice set	M08.01 and M08.02. State point and slope separately. Standard: finish C01.05 and record exact test output.
6	W01 opening; review R1	W01.01 and R1.05; CD.03. Explain a correction without the answer open. Defer any unfamiliar computing notation for a focused C01 repair.
7	Your error log	Fresh reserved M05.07 and M08.07; explain C01.05 from a blank file when ready. Record unaided versus hinted work.

Each row may take several sessions. Do not race a calendar. A task is fresh only when its solution has not already been read. Keep the complete independent set before the solution section, and preserve unfinished work instead of replacing it with a cleaned-up answer.

Score your work on five dimensions#

Score setup, reasoning, execution, verification, and communication separately. The reviews, checkpoints, and assessments in this book use these five dimensions.

Setup: the object, the question, the assumptions, and the method you chose.
Reasoning: why the method applies, with each step justified.
Execution: the algebra, arithmetic, proof steps, or code, carried out correctly.
Verification: an independent check, such as substitution, a limiting case, a units check, a test, or a second method.
Communication: a result another person can follow and check, in the requested form and units.

A correct final number with an invalid argument does not satisfy all five dimensions.

The record to keep. After each session, write down the identifiers you completed, your original unaided attempt, the approximate time, the hints you consulted, the first incorrect step, and one explanation you could not give. For code, add the exact command, the expected and actual output, the failing test, and the function you changed. This record is also what to bring to a tutor, a study group, or an instructor. “I treated $f(x+h)$ as $f(x)+h$ ” is actionable. “I am bad at math” does not identify a repair.

Give each error one category: notation or syntax; concepts; method choice; algebra; proof assumptions; program state; test coverage; interpretation; or performance reasoning. LM, the first chapter of Part I, turns this record into an error log with review dates and names four error families that recur in calculus.

Retention, and AI without surrendering the work#

Review new material after a day and again at about days 3, 7, 14, and 30, adjusting to your errors rather than treating these as memory laws; a logged error gets its own review dates (LM, section F). Mix earlier problem types once you have learned their basic methods. Ask for the smallest useful hint only after recording where you are stuck. Close the explanation, repair the work, and teach it back in your own words. Predict what code will do before running it. Do not count a pasted reference solution’s passing tests as your independent implementation. Section I of LM sets the rules for AI help that every track in this book follows.