Math lessons & courses

Second derivatives buy something gradients cannot: a step shaped by curvature, immune to conditioning, converging quadratically. This lesson builds Newton's method, then layers it on a log barrier to get interior point methods, the machinery that made large constrained problems solvable with a certificate rather than a hope.

Gradient descent is three lines of code and a hundred years of theory. This lesson derives why a safe step size is one over the smoothness constant, why the condition number governs everything, and why acceleration reaching order one over k squared is provably the best any first-order method can do.

Convexity is what separates optimization problems you can solve with a guarantee from ones you can only hope about. This lesson defines convex sets and functions, proves why every local minimum is global, and gives you the operations that let you recognise convexity without touching a Hessian.

Quadratics, cubics and quartics all have formulas in radicals. The general fifth-degree equation has none, and not because nobody clever enough has tried. This lesson explains how permuting the roots turns an algebra question into a group question, and why the answer changes at degree five when a group of order 60 refuses to break down.

Group theory earns its keep when a symmetry argument settles a physical question no calculation was going to answer. This lesson covers group actions and counting up to symmetry, why crystals cannot have five-fold rotation and what happened when one did, Noether's link between symmetry and conservation, and how the same idea is built into modern networks.

Cosets cut a group into equal-sized blocks, and one counting argument then forces every subgroup's size to divide the group's. This lesson proves that, derives Fermat's little theorem from it as a corollary, and introduces the maps that let you compare two groups and say precisely when they are the same object.

A group is a set with one operation obeying four rules, and that deliberate poverty is the point: anything proved about groups holds for rotations, permutations, integers, XOR and Rubik's cube at once. This lesson builds the definition from symmetry, works through the symmetries of a square, and shows where groups already sit in code.

Wrap the number line into a circle and addition and multiplication survive intact while division mostly does not. This lesson builds congruences, shows why you can reduce early to avoid overflow, works through Euclid's algorithm and modular inverses, and explains how a million-digit exponent becomes twenty multiplications.

A graph is two sets and an incidence relation, and that austerity is why the same object models build dependencies, social networks, register allocation and road maps. This lesson covers the structural properties worth knowing, the special families that make hard problems easy, and the line where a small change to a question makes it intractable.

Testing checks the cases you thought of; a proof covers all of them at once, including the ones nobody will ever run. This lesson builds direct proof, contradiction and induction as working tools, shows the two ways induction fails, and connects it to the loop invariants that make a program correct rather than merely untested.

Combinatorics answers how many arrangements exist without producing any of them, which is what makes password strength, hash collisions and search-space size computable at all. This lesson builds the product rule, permutations, combinations, inclusion-exclusion and the pigeonhole principle, then applies them to problems where intuition is reliably wrong.

A spectrum shows you artefacts of the analysis alongside the signal, and telling them apart is a learnable skill. This lesson covers spectral leakage, what windows buy and what they cost, why zero-padding does not add resolution, and the hard trade a spectrogram forces between knowing when and knowing what.

A filter is fully described by what it does to a single impulse, and applying it is a convolution. This lesson builds that idea, shows why the frequency domain turns convolution into plain multiplication, and works through the trade-offs that make real filters ring, lag, or cost more than they need to.

Turning a continuous signal into numbers is safe only above a specific rate, and below it the damage is silent and permanent. This lesson derives the Nyquist limit, shows exactly where a too-high frequency reappears, and explains why the fix has to be analogue and has to happen before the converter.

The same signal can be written as a function of time or as a recipe of frequencies. This lesson explains why sinusoids in particular get that job, builds the discrete Fourier transform, and shows how the FFT turned a quadratic computation into one you can run on a million samples in a fraction of a second.

Frameworks do not differentiate formulas symbolically or estimate derivatives numerically. They differentiate the program. This lesson builds forward mode from dual numbers and reverse mode from the backward sweep, shows why a full gradient costs about four function evaluations at any size, and where the answer is not what you meant.

A deep network is a composition, so its derivative is a product of Jacobians. This lesson builds the chain rule from one variable up to matrix form, shows that the order you multiply that product in changes the cost tenfold, and explains vanishing gradients as an arithmetic consequence rather than a mystery.

One derivative becomes three objects once a function has many inputs and many outputs. This lesson builds the gradient, the Jacobian and the Hessian, shows what each one actually tells you, and explains why curvature decides how many steps an optimiser needs and why nobody ever writes the Hessian down.

Machine learning uses the derivative as a search strategy, not a symbolic exercise. This lesson builds it as the best local linear approximation, derives the gradient descent update from it, and shows why estimating derivatives numerically loses half your digits and costs one function evaluation per parameter.

Where this machinery earns its place: low-rank matrix completion, synchronization, and PCA. Plus the two ideas that explain why non-convex manifold problems are often solved to global optimality anyway.

How to move along a curved space without solving differential equations: retractions as cheap approximations to geodesics, vector transport, and the Riemannian versions of gradient descent, conjugate gradients, and trust regions.

Building the machinery: the linear space of allowed directions at a point, the inner product that gives it geometry, and why the Riemannian gradient is the ambient gradient projected rather than a new derivative.

Rotations, subspaces, low-rank matrices and covariances are not vectors in flat space. Why treating those constraints as penalties or projections wastes structure, and what it means to say the search space is a manifold.

Build the vocabulary that underlies all of ML: sample spaces, discrete and continuous random variables, PMFs, PDFs, and CDFs. Then tour the key distributions — Bernoulli, Binomial, Categorical, Gaussian, Poisson, Exponential, Uniform — with their parameters, mean, variance, and exactly when each appears in practice.