Multilevel Monte Carlo

Pricing a path-dependent derivative by simulation usually means discretizing time into small steps — the finer the steps, the more accurate the simulated path, but also the more computing time each path costs. Wanting both a fine, accurate grid and millions of independent paths to control the pure sampling noise means the total cost multiplies: fine grid times many paths equals very expensive. Multilevel Monte Carlo (MLMC) breaks this trade-off by cleverly combining simulations at several grid resolutions, doing most of the expensive fine-grid work only on a small correction term, so the total computing budget needed to hit a target accuracy drops sharply — often by an order of magnitude — compared to running everything at the fine grid alone.

An analogy: measuring a coastline with a coarse map and small corrections

Imagine estimating the length of a coastline. A coarse map gives you a rough length quickly and cheaply, but it's biased — it misses small wiggles a finer map would capture. Getting a truly fine map for the entire coastline is expensive. Instead, you could measure the whole coast cheaply on the coarse map, and then, for just a handful of the wiggliest-looking stretches, measure the difference between the coarse and fine estimate on that stretch alone — a small, cheap correction. Add the coarse estimate to the average correction, and you get something close to the fine-map answer without ever fully mapping the whole coast at fine resolution. MLMC applies exactly this logic to simulated paths: cheap coarse simulations for the bulk of the estimate, and a small number of paired coarse-versus-fine comparisons to correct the bias.

The method, one symbol at a time

Let $P_\ell$ denote the (biased) estimate of your target quantity computed on discretization level $\ell$, where level 0 is the coarsest grid and higher $\ell$ means finer time steps (say, doubling the number of steps each level). Write the fine-level estimate as a telescoping sum of corrections:

$$\mathbb{E}[P_L] = \mathbb{E}[P_0] + \sum_{\ell=1}^{L} \mathbb{E}[P_\ell - P_{\ell-1}],$$

where $L$ is the finest level you care about. This is just algebra — the sum of consecutive differences collapses back to $P_L$ — but it changes how you estimate each piece. You estimate $\mathbb{E}[P_0]$ with many cheap coarse-grid simulations, and you estimate each correction term $\mathbb{E}[P_\ell - P_{\ell-1}]$ using paired simulations: the same underlying random path, run once on the coarse grid and once on the fine grid, then differenced. Because the coarse and fine paths use the same randomness, the difference $P_\ell - P_{\ell-1}$ is typically small and low-variance — much smaller than either $P_\ell$ or $P_{\ell-1}$ individually — meaning each correction level needs only a modest number of paired paths, and the finest, most expensive level needs the fewest paths of all.

The total cost is allocated across levels to minimize variance for a fixed budget: coarse levels get many cheap paths, fine levels get few expensive paths, following an optimal allocation proportional to $\sqrt{V_\ell / C_\ell}$ where $V_\ell$ is the level's correction variance and $C_\ell$ its per-path cost.

The explorer below simulates GBM paths at whatever resolution you choose; try comparing a coarse path against a fine one built from the same random seed and notice how closely they track each other — that closeness is exactly what makes the coarse-fine correction term small and cheap to estimate.

Worked example: pricing a path-dependent option

Suppose pricing an Asian option (averaging the stock price over 256 time steps) directly at full resolution with 1,000,000 paths costs, say, 256 million total step-computations. With MLMC using levels of 1, 4, 16, 64, and 256 steps: you run 500,000 cheap paths at 1 step (level 0) to get the bulk of the answer, then only 50,000 paired paths at the 1-vs-4-step correction, 10,000 at 4-vs-16, 2,000 at 16-vs-64, and just 500 paired paths at the expensive 64-vs-256 correction — because that correction's variance is tiny (the paths agree closely at that resolution) so few pairs are needed to estimate its small mean reliably. The total step-computations across all levels might sum to only 20–30 million — roughly a tenfold saving over running a million paths at full 256-step resolution, for the same target accuracy.

Worked example: why the correction shrinks

Take a simple SDE approximated by the Euler scheme with strong order of convergence $1/2$, meaning the typical path-wise error at step size $h$ scales like $\sqrt{h}$. Halving the step size (level $\ell$ to $\ell+1$) roughly halves this error's scale, so the variance of the difference $P_{\ell+1} - P_\ell$ shrinks by about a factor of 2 at each level (for schemes with the Milstein correction, this shrinkage is even faster, by a factor of 4). This geometric decay in correction variance is exactly what lets MLMC allocate exponentially fewer paths to each successively finer level while keeping total variance controlled.

What this means in practice

MLMC is used wherever a simulation needs both fine time discretization and low Monte Carlo noise: pricing path-dependent options, computing risk sensitivities (Greeks) under stochastic volatility models, and CVA/XVA calculations that require nested simulation. It turns an otherwise prohibitive computing budget into a tractable one, particularly for models without closed-form solutions where a fine grid is mandatory for accuracy. It composes with other variance-reduction tricks like antithetic variates and conditional Monte Carlo (see variance reduction in Monte Carlo pricing and conditional Monte Carlo) — MLMC decides how to split work across resolutions, while those techniques further reduce variance within each level.