Lessons

The count-min sketch estimates how often an item occurred using a fixed grid of counters, and it never underestimates. This lesson builds it, states the error bound that makes it usable, shows where it is useless, and ends on the property shared by all three structures that explains why they run distributed systems.

Counting distinct items exactly needs memory proportional to the count. HyperLogLog answers the same question in a fixed twelve kilobytes, for cardinalities into the billions, by measuring an improbable event rather than storing anything. This lesson builds that idea from the leading-zeros intuition up.

A Bloom filter answers set membership using a bit array and a handful of hash functions, with no items stored anywhere. This lesson builds it, derives the sizing formula that trades memory against false positives, explains exactly why deletion is impossible, and covers the variants that buy it back.

Answering set questions exactly costs memory proportional to the data, which fails once the data does not fit. Probabilistic data structures accept a quantified error in exchange for memory that stays constant. This lesson establishes what that trade buys, and why the shape of the error matters more than its size.

Central clearing was extended after the financial crisis because it removes counterparty risk from the network. It does not remove it from the system: it concentrates it in a small number of institutions that are now indispensable. This lesson assesses what was gained, what was created, and how to read any infrastructure change for the risk it relocates.

Settlement is one instant of exchange, and getting it right means never letting the two legs come apart. This lesson covers delivery versus payment, where securities actually live and who is in the chain, why settlement fails are routine rather than scandalous, and what shortening the cycle costs.

A CCP takes the other side of every trade, which means one member's failure becomes its problem and therefore everyone's. This lesson covers how it survives that: the margin it collects, the ordered stack of resources it burns through in a default, and the deliberate design choice of putting its own capital ahead of the mutualised fund.

A trade is agreed in microseconds and completed days later. In between, both sides hold a promise rather than an asset, and either could fail. This lesson builds the trade lifecycle, explains why the gap exists at all, and introduces the legal manoeuvre that lets a stranger's creditworthiness stop being your problem.

Execution costs are small numbers buried in large noise, so distinguishing a good desk from a lucky one takes more data than most institutions have. This lesson covers what transaction cost analysis can establish, the reversion test that detects information leakage, and what happens to any measure once people are paid on it.

A schedule says how much to trade and when. It says nothing about how each slice is sent, and that choice determines much of the realised cost. This lesson covers the standard algorithm families and what each one's benchmark actually rewards, then the placement decisions underneath: passive against aggressive, displayed against hidden, and which venue.

Trading fast costs impact. Trading slowly exposes the order to drift. Neither can be minimised without worsening the other, so the schedule is an optimisation with a parameter that encodes urgency. This lesson builds that trade-off, derives the shape of the resulting trajectory, and identifies what the model cannot see.

The cost of a trade is not the commission, and it is not the spread. It is the gap between the return the decision would have produced on paper and the return the account actually got. This lesson builds that measure, decomposes it into four sources, and shows why the largest component is often the trade nobody made.

Measuring risk and surviving it are different problems, and only the second is solved by a decision. This lesson covers the growth-optimal bet size, why practitioners deliberately use a fraction of it, the asymmetry that makes drawdowns so expensive to recover from, and why limits work as a control system rather than a prediction.

Leverage does not simply scale returns. It introduces a lender who can demand cash at the worst moment, which converts a paper loss into a forced sale. This lesson works through margin mechanics, shows why the liquidation price rather than the loss is what matters, and follows the feedback loop that makes market and funding liquidity reinforce each other.

Every risk number is a functional applied to an estimated distribution, so its errors are that distribution's errors. Returns have fat tails, volatility clusters, and correlations converge exactly when diversification is supposed to help. This lesson covers each failure, why they arrive together, and what stress testing does that no quantile can.

Value at Risk compresses a whole loss distribution into one number, which is why it was adopted everywhere and why it misleads. This lesson builds it three ways, shows the arithmetic case where it says diversification increased risk, and covers the coherence axioms that explain the failure and the measure regulators moved to instead.

If the pricing model were right, implied volatility would be one number per underlying. It is not: it varies by strike and by maturity, in a persistent shape. This lesson treats that shape as data rather than as a defect, shows what it reveals about the market's distribution, and separates forecast from risk premium.

Delta-hedging removes the obvious risk and leaves the interesting ones. The greeks name each remaining exposure separately, which is what lets a trader hold some and neutralise others. This lesson covers what each one measures, why gamma and theta are two sides of one trade, and where the numbers stop behaving.

The Black-Scholes contribution is usually remembered as a formula. It is really an argument: an option can be manufactured from the underlying and cash, so its price is the cost of manufacturing it. This lesson builds that replication argument, shows why the asset's expected return cancels out, and locates each assumption where it fails.

An option's value at expiry is trivial arithmetic. Its value before expiry is a hard modelling problem. Between those two facts sits put-call parity, which pins calls and puts to each other using no model at all, only the impossibility of free money. This lesson builds the contracts and that relation.

The order book is not a law of nature. Someone chose the tick size, the priority rule, and whether trading runs continuously or in batches, and each choice determines who profits. This lesson reads the latency arms race as a predictable consequence of one design decision rather than a moral failure, and covers what changes when the design does.

Nobody announces what an asset is worth, yet prices move toward it. The mechanism is order flow: trading is how private information becomes public price. This lesson builds Kyle's model of that process, separates the part of your impact that is permanent from the part that reverts, and explains why size costs more than depth alone predicts.

Competition should compress the bid-ask spread to nothing, and it does not. The reason is not fees or greed: a spread survives even when trading is free and the quoting participant expects zero profit. This lesson builds the adverse selection argument, then shows how to measure which part of a spread is information and which part is rent.

A market price is not published by anyone. It is the residue of a queue of resting orders and the orders that consume them. This lesson builds the limit order book and its matching rules, shows what a fill actually costs, and takes apart the assumption that an instrument has one price at all.