Paths, options, and correlated inputs

What changes when time enters

In Part 2 a scenario was a growth rate, a margin, a multiple. Many real problems refuse to be summarised that way: an option's payoff can depend on the average price over a year, or on whether a barrier was ever touched; a patient's outcome depends on a disease path; a queue's performance depends on its entire arrival history. The random object is now a function of time, and one scenario is a path - a vector of values at many time points.

The good news you already own: Part 1 proved the Monte Carlo error rate contains no dimension. A path sampled at 252 daily points is a 252-dimensional random vector, and the estimator does not care. So nothing here is new statistics - it is new model-building: how to construct paths whose randomness has the right structure. It arrives in three steps.

• The random walk. Start at zero and add an independent shock each period. Two properties define everything that follows: increments are independent - tomorrow's surprise doesn't remember today's - and the variance of the position grows linearly in time, so the typical displacement grows like the square root of t. You have met that square root before wearing a different costume: it is the same one from the standard error, and honestly so, because a random walk is a running sum of independent draws.
• Brownian motion. Let the period shrink to zero while holding variance-per-unit-time fixed and the walk becomes continuous. For simulation you need exactly one fact: over any interval, the increment is normal with variance equal to the interval's length, independent of everything before. On a grid, a Brownian path is just the cumulative sum of independent normal draws - the random walk again, with no apology needed.
• Geometric Brownian motion. Prices can't go negative, and shocks are naturally proportional - the stock moved 2%, never 2 dollars regardless of level. That is Part 2's lognormal country, so model the log of the price as a random walk with drift. The payoff is that the resulting equation has an exact solution, and the exact solution is the simulation recipe.

So a path is: generate a row of independent normals, turn each into a log-increment with that formula, take the cumulative sum, exponentiate. Rows are worlds, columns are time - the exact array discipline from Part 2's DCF, now with 252 columns instead of 5.

The minus sigma squared over two is a load-bearing wall

Every beginner looks at that formula and asks the same question: what is that correction doing there, and can I drop it? You can, and your asset will then earn about 3.2% a year out of thin air at 25% volatility. Nothing will crash. The paths will look completely plausible.

Here is the cleanest way to hold it, and it is Part 2's lesson returning with a vengeance. For a lognormal variable the mean of the exponential exceeds the exponential of the mean, because exponentiating is convex and the upside of a symmetric shock outweighs its downside once you exponentiate. That is Jensen. It is always Jensen. So if you want your simulated price to have expected growth rate mu - which is what “drift mu” means - you must set the drift of the log to mu minus half sigma squared, precisely so that the convexity bonus restores it.

The same fact wearing its finance costume: a stock with 25% volatility whose log-return averages zero loses nothing on average in price terms - but its median path decays. Volatility drags the median down by half sigma squared per year even as the mean stays flat, because the mean is held up by a shrinking minority of huge paths. That is “volatility drag” in retirement planning and the “variance tax” in trading folklore. All the same term.

Option pricing: the workflow your colleagues actually meant

When a valuation team says “we'll price the option by Monte Carlo with GBM”, they mean four lines. Simulate N terminal prices under GBM with the drift set to the risk-free rate - not the stock's real expected return. Compute the payoff in each world. Average. Discount at the risk-free rate.

Three of those four are Part 1's engine verbatim: a price expressed as a discounted expectation, estimated by an average, error bar attached. The entire novelty is the strange instruction in the first one.

Why the drift becomes the risk-free rate, in honest plain language. Part 2 met the puzzle already: when valuing risky cash flows, riskiness has to be priced somewhere - there we kept the scenarios realistic and priced risk in the discount rate. Option pricing resolves the same tension in the opposite, cleverer direction: distort the scenarios, simplify the discounting.

The deep fact is that an option's payoff can be replicated by a continuously rebalanced portfolio of the stock and cash. Two assets with identical payoffs in every state must have identical prices - otherwise free money - so the option's price is the cost of the replicating portfolio. And here is the punchline: when you grind through that replication argument, the stock's actual expected return cancels out of the answer entirely. It has to, because the hedge neutralises the stock's direction, so how strongly the stock trends cannot matter. Only the starting price, the strike, the horizon, the rate and the volatility survive.

Since the real drift doesn't appear in the answer, we are free to compute the answer in whichever fictional world makes the computation easiest - and the easiest is the one where every asset drifts at the risk-free rate, because there, pricing collapses to a discounted expected payoff, which is exactly a Monte Carlo average. That world is called the risk-neutral measure.

Certify it against Black-Scholes

The European call has a closed-form price, which makes it the perfect certification target: we never need Monte Carlo for it, and that is exactly why we start there. The blue band is the simulation's estimate give or take two standard errors; the black line is the exact answer. A pass isn't “the numbers look close” - it is the disagreement measured in units of the standard error, with the criterion stated in advance.

Two things to try. Drag the paths up and watch the band narrow around the exact line at the familiar square-root rate - the error bar is honest, and it contains the truth. Then tick the bug: the price jumps and the band stays exactly as narrow as before. That is the whole point. A tight error bar tells you the simulation is precise, never that it is right.

Greeks, and the quiet star of the whole guide

A price alone is half a deliverable; desks live on sensitivities. Delta - how the price moves when the stock moves - is the obvious one, and the obvious estimator is a finite difference: price at a slightly higher spot, price at a slightly lower one, subtract, divide by the gap. Here Monte Carlo lays a trap that teaches a beautiful lesson.

Use independent random draws for the two bumped prices and each carries its own noise; the difference of two noisy numbers divided by a small gap amplifies that noise catastrophically. Measured: delta = 0.5112 give or take 0.0226 - a 4%-wide error bar on a quantity of size 0.52, which is garbage for hedging.

Now the fix, which costs exactly zero extra computation: use the same normal draws for both bumps. Common random numbers. Each scenario's noise now appears in both prices and cancels in the subtraction; what survives is precisely the systematic effect of the bump. Result: 0.5195 give or take 0.0012, against a true Black-Scholes delta of 0.5199 - a measured variance reduction of 349 times. Same estimator, same N, one line about seed discipline, two and a half decimal digits purchased for free.

Correlated inputs: sin 4 comes due

Part 2's fourth deadly sin - independence by default, silently - was allowed at entry level with a confession attached. This is where the confession stops being enough, and one table explains why. Take an equal-weight portfolio of ten assets, each with the same 20% volatility, and vary only how correlated they are:

At zero correlation, diversification works exactly as theory promises - the portfolio volatility is the single-asset volatility divided by the square root of ten, which is another free certification. At 0.6 - an unremarkable correlation for equities in a stressed market - the bad-year loss is two and a half times worse than the independent model claims. Every marginal distribution in both models is identical. The entire difference is dependence.

Turn the correlation dial

Ten assets, each with exactly the same 20% volatility no matter where the dial sits. Only their dependence changes. Watch what that alone does to the left tail - the part of the distribution that pays your losses.

Nothing about any individual asset changed between the two ends of that dial. Every one of them still has a 20% volatility and the same bell-shaped distribution. Only the wiring between them moved - and the bad year got three times worse.

Cholesky, copulas, and the 2008 lesson

So we need to generate correlated inputs. For the multivariate normal case there is a complete, exact, three-line answer, and it is worth understanding rather than merely calling.

The goal: given a target correlation matrix, produce vectors with that covariance out of the independent normals your generator supplies. Any linear map applied to independent normals produces a covariance equal to the map times its own transpose. So the task reduces to factoring the target matrix into a factor and its transpose - and choosing that factor lower-triangular makes the factorisation unique, cheap and interpretable. That is the Cholesky decomposition, and it is one library call.

The interpretation is the valuable part. Each row of that factor is a mixing recipe: variable k is built from the first k independent noise sources, with weights chosen so its covariances with the earlier variables come out exactly right and its total variance stays at one. Variable 1 is pure factor 1; variable 2 is some parts factor 1 plus enough fresh factor 2 to top up the variance; and so on. Cholesky is a factor model in disguise - each variable equals loadings on common factors plus its own idiosyncratic noise - which is exactly how practitioners think about dependence even when they never say the word.

Copulas: dependence with any marginals

Cholesky solves the normal case. But Part 2 taught you that real inputs are lognormal, triangular, empirical - and you still need them correlated. Enter the copula, which is nothing more mysterious than Part 2's percentile machine run in both directions. Generate correlated normals with Cholesky. Squash each coordinate through its own normal CDF to get correlated uniforms - any variable through its own CDF becomes uniform, and the dependence survives the squashing. Then push each uniform through whatever inverse CDF you want for that input.

Marginals and dependence are now fully decoupled: you can hand each input its honest distribution and still wire the inputs together. That object is the Gaussian copula, and this three-step recipe is how sin 4 actually gets fixed in production cost and valuation models.

The transferable lesson costs one sentence: correlation is one number, dependence is a whole function, and the difference between them lives in the tails - which is where you get paid or destroyed.

What's next

• Part 4 - beating the square-root law. Every halving of the error bar quadruples the bill - unless you stop buying runs and start shrinking the variance. Antithetic and control variates (the Asian option's error bar collapses by a factor of 35), importance sampling that turns a hopeless one-in-a-million estimate routine, quasi-Monte Carlo, and the bridge to MCMC.

New here? Part 1 builds the engine, Part 2 the recipe and two projects, and the series hub lists all four.