We use essential cookies to run the site (session, security, and your theme/language preferences). With your permission we also load embedded third-party content, such as YouTube videos. Cookie Policy
When the answer is the average of a million what-ifs
Author(s):Elier Rodríguez García
Index
Introduction
A financial option is a contract that gives you the right — but not the obligation — to buy or sell an asset at an agreed price on some future date. A call option on a stock, for example, pays off when the stock rises above the agreed strike priceK: the payoff is max(ST−K,0), where ST is the stock price at expiry.
Pricing a simple European option has an elegant closed-form solution: the famous Black–Scholes formula, published by Fischer Black, Myron Scholes, and Robert Merton in 1973. It assumes the stock price follows a geometric Brownian motion — continuous random drift with a fixed volatility — and produces a single equation you can evaluate in a spreadsheet.
But real contracts are often path-dependent: an Asian option pays based on the average price over the whole period; a barrier option disappears if the stock ever touches a threshold. For these, no closed formula exists. The integral over all possible paths is too complicated to solve analytically.
Enter Monte Carlo simulation. Instead of solving the integral, you sample it: generate thousands of possible price paths, compute the payoff on each one, and average the results. The law of large numbers guarantees the average converges to the true price. The more paths you simulate, the tighter your estimate — and because each path is independent, the work scales perfectly across processors.
Try It
Adjust the sliders and press Run simulation to simulate many asset paths under geometric Brownian motion and estimate the call option price. Each thin line is one possible future for the stock; the bold line is the average path. The estimated price updates with each new batch.
const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Model: geometric Brownian motion (GBM) — log-normal stock returns.
// Price a European call: payoff = max(S_T - K, 0), discounted at risk-free rate r.
const S0 = 100; // initial stock price
const T = 1.0; // time to expiry in years
const r = 0.05; // risk-free rate
const STEPS = 52; // weekly steps per path
const pathsSlider = document.getElementById('paths');
const volSlider = document.getElementById('vol');
const strikeSlider = document.getElementById('strike');
const pathsVal = document.getElementById('pathsVal');
const volVal = document.getElementById('volVal');
const strikeVal = document.getElementById('strikeVal');
const runBtn = document.getElementById('runBtn');
const resultDiv = document.getElementById('result');
const canvas = document.getElementById('chart');
const ctx = canvas.getContext('2d');
// Keep slider display labels in sync
pathsSlider.addEventListener('input', () => { pathsVal.textContent = pathsSlider.value; });
volSlider.addEventListener('input', () => { volVal.textContent = volSlider.value; });
strikeSlider.addEventListener('input', () => { strikeVal.textContent = strikeSlider.value; });
// Simulate one GBM path and return the final payoff for a call option.
function simulatePath(sigma, K) {
const dt = T / STEPS;
const mu = r - 0.5 * sigma * sigma;
let S = S0;
const path = [S];
for (let i = 0; i < STEPS; i++) {
// Box-Muller transform: standard normal sample
const u1 = Math.random(), u2 = Math.random();
const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
S = S * Math.exp(mu * dt + sigma * Math.sqrt(dt) * z);
path.push(S);
}
// call option payoff at expiry
const payoff = Math.max(path[path.length - 1] - K, 0);
return { path, payoff };
}
function drawChart(paths, avgPath) {
const W = canvas.width, H = canvas.height;
ctx.clearRect(0, 0, W, H);
// Find min/max across all paths for y-axis scaling
let minP = Infinity, maxP = -Infinity;
for (const { path } of paths) for (const p of path) {
if (p < minP) minP = p;
if (p > maxP) maxP = p;
}
for (const p of avgPath) { if (p < minP) minP = p; if (p > maxP) maxP = p; }
const pad = 20;
const xScale = (W - pad * 2) / STEPS;
const yScale = (H - pad * 2) / (maxP - minP || 1);
const toX = i => pad + i * xScale;
const toY = p => H - pad - (p - minP) * yScale;
// Draw up to 100 sample paths (the rest are used only for the average)
ctx.lineWidth = 0.6;
const maxShow = Math.min(paths.length, 100);
for (let pi = 0; pi < maxShow; pi++) {
const { path } = paths[pi];
ctx.strokeStyle = 'rgba(150,188,220,0.45)';
ctx.beginPath();
path.forEach((p, i) => i === 0 ? ctx.moveTo(toX(i), toY(p)) : ctx.lineTo(toX(i), toY(p)));
ctx.stroke();
}
// Dashed line at the strike price
ctx.strokeStyle = '#c5d0da';
ctx.lineWidth = 1;
ctx.setLineDash([4, 3]);
const sY = toY(parseFloat(strikeSlider.value));
ctx.beginPath(); ctx.moveTo(pad, sY); ctx.lineTo(W - pad, sY); ctx.stroke();
ctx.setLineDash([]);
// Bold red average path
ctx.strokeStyle = '#e63946';
ctx.lineWidth = 2;
ctx.beginPath();
avgPath.forEach((p, i) => i === 0 ? ctx.moveTo(toX(i), toY(p)) : ctx.lineTo(toX(i), toY(p)));
ctx.stroke();
}
function run() {
const n = parseInt(pathsSlider.value, 10);
const sigma = parseInt(volSlider.value, 10) / 100;
const K = parseInt(strikeSlider.value, 10);
const results = [];
for (let i = 0; i < n; i++) results.push(simulatePath(sigma, K));
// Element-wise average across all simulated paths
const avgPath = Array.from({ length: STEPS + 1 }, (_, i) =>
results.reduce((sum, r) => sum + r.path[i], 0) / n
);
// Average payoff discounted to present value
const avgPayoff = results.reduce((sum, r) => sum + r.payoff, 0) / n;
const price = avgPayoff * Math.exp(-r * T);
drawChart(results, avgPath);
resultDiv.textContent = i18nFmt('Estimated call price: $%price% (from %n% paths)', { n, price: price.toFixed(2) });
}
runBtn.addEventListener('click', run);
run(); // Run once on page load with default values
Result
Console
Notice how the price estimate bounces wildly with just a handful of paths, then settles as you add thousands more. The convergence is slow — the error shrinks like 1/n — but it is relentless. For path-dependent options where no formula exists, this is the only practical route to a price.
The Real Complexity
Monte Carlo pricing looks almost too simple — just sample and average. The interesting complexity lives in the convergence rate and the tricks for speeding it up.
Why 1/n convergence matters. To halve the pricing error you must quadruple the number of paths. This is the statistical cost of randomness: regardless of how many dimensions the problem has, the error is always O(1/n). That dimension-independence is the method's great strength — a 252-step daily path (one trading year) is no harder than a 10-step monthly one.
Variance reduction is the art of getting more accuracy per path:
Antithetic variates: for every random path, run its mirror image (negate the random shocks). Pairs tend to be negatively correlated, so averaging them cancels much of the variance.
Control variates: if you know the exact price of a simpler option, use the Monte Carlo price of that option as a correction factor.
Importance sampling: tilt the distribution toward the rare events that matter most (e.g., very high stock prices for a deep out-of-the-money call).
Quasi-Monte Carlo (QMC) replaces pseudo-random sequences with carefully designed low-discrepancy sequences (Sobol, Halton) that cover the space more evenly. For smooth integrands QMC can achieve O((logn)d/n) — much faster in low dimension, though the advantage shrinks as the number of time steps grows.
The real computational bottleneck is not arithmetic but memory and parallelism: pricing a portfolio of thousands of options on a trading desk requires simulating millions of paths in milliseconds. This is why Monte Carlo is a natural fit for GPUs, where thousands of cores each compute independent paths simultaneously.
Where It Matters
Whenever an integral is too complex to solve analytically, Monte Carlo is the tool of first resort:
Exotic derivatives: Asian, barrier, lookback, and rainbow options all depend on the entire path of one or more assets. Monte Carlo handles any payoff function you can write in code.
Value at Risk (VaR) and Expected Shortfall: regulators require banks to estimate potential losses over a horizon. Simulating thousands of market scenarios and reading off the tail is the standard approach.
Credit risk: pricing collateralized debt obligations (CDOs) requires simulating correlated defaults across hundreds of loans — a problem that became infamous in the 2008 financial crisis when the models were misused.
Real options: evaluating whether to expand a factory, drill an oil well, or launch a product — decisions that depend on future prices — uses the same path-simulation logic.
Beyond finance: the same idea prices insurance contracts, estimates radioactive shielding thickness (the original Monte Carlo use at Los Alamos in 1946), and runs probabilistic inference in machine learning.
Wherever a closed form is unavailable and the integral is high-dimensional, the motto is: simulate, average, repeat.
Conclusion
Monte Carlo option pricing is a masterclass in trading exactness for universality. Where Black–Scholes gives a precise answer for a narrow class of contracts, Monte Carlo gives an approximate answer for any contract you can describe.
The convergence rate O(1/n) is a fundamental limit of randomness — not a flaw in the algorithm but a property of estimation by sampling. Variance reduction techniques and quasi-random sequences push the frontier, but they cannot escape the underlying statistical uncertainty.
What makes the method remarkable is its simplicity: generate a path, compute a payoff, average. Every additional path is independent, so the computation is embarrassingly parallel — the same structure that lets neural network training run on thousands of GPU cores. In a world of intractable integrals, randomness turns out to be one of the most powerful computational tools we have.
Comments
Loading comments...