Monte Carlo — the workhorse

Monte Carlo simulation is the most general pricing method in derivatives. Simulate paths of the underlying, compute the payoff on each path, average the discounted payoffs. Works for any payoff function — high-dimensional, path-dependent, exotic — and converges at a dimension-independent O(1/√N) rate. The price of generality is a square-root convergence rate that variance-reduction techniques can dramatically improve.

The basic MC algorithm

1. Specify the SDE under Q for the underlying(s).
2. Choose number of paths N (typically 10⁴-10⁶) and time steps M.
3. For each path: generate sequence of random normals; integrate the SDE (often Euler or log-Euler).
4. Compute the payoff for each path.
5. Average: V̂ = (1/N) Σ_p discount × payoff_p.
6. Standard error: SE = sample std / √N.

GBM Monte Carlo via log-Euler

import numpy as np
N = 100_000; T = 1.0; M = 252
dt = T / M
S = np.full(N, S0)
for _ in range(M):
    Z = np.random.randn(N)
    S *= np.exp((r - 0.5*sigma**2)*dt + sigma*np.sqrt(dt)*Z)
payoff = np.maximum(S - K, 0)
price = np.exp(-r*T) * payoff.mean()
se = np.exp(-r*T) * payoff.std() / np.sqrt(N)

For European vanilla options, terminal value alone is needed — generate S(T) directly without intermediate steps. M = 1 suffices for vanilla options on GBM. M > 1 needed only for path-dependent payoffs.

Convergence and standard error

V̂_N → V    a.s. (SLLN)
√N (V̂_N - V) → N(0, σ_pay²)    (CLT)
SE(V̂_N) ≈ σ̂_pay / √N

Doubling N halves SE — slow. 100× more accurate requires 10,000× more paths. Variance reduction techniques (Module 7) can boost effective N by 10-1000× without changing N itself.

Confidence intervals

95% CI: V̂ ± 1.96 SE. Tighter than VaR-style sampling because the CLT works fast for sums of bounded payoff functions. For deep out-of-the-money options where most paths contribute zero, the convergence can be much slower.

Discretisation error

Euler simulation of the SDE introduces O(Δt) bias on top of O(1/√N) sampling error. For exact-in-distribution simulation of GBM (log-Euler), discretisation error is zero. For SDEs without exact simulation (CIR with state-dependent vol), use Milstein, or use fine time steps and bias-correction.

Random number generation

• Pseudo-random: Mersenne Twister, PCG, etc. Reproducible with a seed.
• Quasi-random: Sobol, Halton, Niederreiter. Lower discrepancy, deterministic. Better for moderate-dimensional integration.
• Box-Muller: convert uniform to normal. Replaced by Marsaglia polar method or inverse-CDF method in production.

Path-dependent options

Asian (averaging strike), Barrier (knock in/out), Lookback (max/min strike). All require simulating full paths. Step size choice matters for barrier options — too-coarse a grid can miss barrier crossings between simulation steps.

Greeks by Monte Carlo

• Bump-and-reprice: rerun MC with S0 + ΔS. Sensitive to MC noise; use common random numbers (same Z's both times).
• Pathwise differentiation: differentiate payoff with respect to the parameter analytically inside the simulation. Better variance.
• Likelihood ratio method: differentiate the density rather than the payoff. Works for non-smooth payoffs (digitals).
• Adjoint AD: vectorised, scales to thousands of Greeks. Used in modern XVA pricing.

When Monte Carlo wins

• High-dimensional (≥ 3 underlyings) — curse of dimensionality kills PDE.
• Complex path-dependence not expressible in low-dim state space.
• Models without closed-form characteristic function or PDE.
• Capital and CVA computations on derivative portfolios.
• Stress tests and scenario analyses.