Jump-Diffusion and Fat-Tailed Price Models

Jump-diffusion models patch the single biggest lie in quantitative finance: that prices move continuously. Geometric Brownian motion (GBM), the engine under Black-Scholes, assumes returns are normally distributed and paths are continuous. Real prices gap — on earnings, central bank decisions, defaults, and flash crashes — and real return distributions have tails far heavier than a normal allows. Jump-diffusion adds discrete, random jumps to the continuous diffusion, producing fat tails, skew, and the volatility smile that GBM cannot. This guide covers why GBM fails, the Merton model and its compound-Poisson jump component, how calibration actually works, and what jumps imply for hedging and risk.

Where GBM breaks

Under GBM, log-returns over an interval are normal with constant volatility, and the path is continuous — you can always trade out of a position at a price arbitrarily close to the last one. Both claims are empirically false:

• Fat tails. Daily equity-index returns have excess kurtosis far above the

normal's zero. Moves of 5+ standard deviations occur orders of magnitude more often than a Gaussian predicts. October 1987 was a ~20-sigma event under GBM — something that should not happen once in the age of the universe.

• Discontinuity. Prices gap across the overnight close, across news, and across

liquidity vacuums. You cannot continuously hedge through a gap; the price you get on the other side can be far from the last quote.

• Negative skew and the smile. Equity index options trade with a pronounced

volatility skew — out-of-the-money puts are expensive relative to a flat-vol model. GBM produces a flat implied-vol surface; the market's persistent skew is direct evidence that participants price in crash risk that GBM ignores.

These are not edge cases. They are the central facts of risk and option pricing, and a model that misses them will misprice tails, under-reserve for losses, and sell crash insurance too cheaply. See extreme value theory for the complementary statistical treatment of the tail.

The Merton jump-diffusion model

Robert Merton's 1976 model keeps the GBM diffusion and adds a compound Poisson jump process. In words: most of the time the price diffuses as usual, but at random times — arriving as a Poisson process with intensity lambda jumps per year — the price multiplies by a random jump factor.

The log-price dynamics are, in plain notation:

dS/S = (mu - lambda*k) dt  +  sigma dW  +  (J - 1) dN

where:

• sigma dW is the usual Brownian diffusion (continuous part),
• dN is a Poisson increment that equals 1 when a jump occurs (rate lambda),
• J is the random jump multiplier; Merton takes log(J) ~ Normal(m, delta^2),
• k = E[J - 1] is the mean jump size, and the -lambda*k drift correction keeps

the discounted price a martingale (no free lunch from the jumps).

The key structural point: returns are now a mixture. On a given interval you draw a Poisson number of jumps; conditional on n jumps the return is normal with a shifted mean and inflated variance. Averaging over the Poisson count produces a distribution with heavier tails and skew (negative if the mean log-jump m < 0, which is the empirically relevant case for equities). This mixture is why a few large moves coexist with many small ones — exactly the empirical picture.

This is one member of the broader family of Lévy processes — processes with independent, stationary increments that allow jumps. Pure-jump variants (variance gamma, CGMY, normal inverse Gaussian) drop the diffusion entirely and model all movement as jumps of varying size; Merton's diffusion-plus-jumps is the most intuitive entry point.

Simulating a jump-diffusion path

The cleanest way to build intuition is to simulate. The code below draws Poisson jump counts per step and adds the corresponding normal jump sizes on top of the diffusion. Compare the resulting return distribution's kurtosis to a pure-GBM path and the fat tails are immediately visible.

import numpy as np

def simulate_merton(S0, mu, sigma, lam, jump_mean, jump_std,
                    T=1.0, steps=252, n_paths=10_000, seed=0):
    """
    lam        : jump intensity (expected jumps per unit time, e.g. per year)
    jump_mean  : mean of log jump size (negative => downward bias / skew)
    jump_std   : std of log jump size
    """
    rng = np.random.default_rng(seed)
    dt = T / steps
    # martingale drift correction for the compensated jump term
    k = np.exp(jump_mean + 0.5 * jump_std**2) - 1.0
    drift = (mu - 0.5 * sigma**2 - lam * k) * dt

    log_paths = np.zeros((n_paths, steps + 1))
    log_paths[:, 0] = np.log(S0)
    for t in range(1, steps + 1):
        z = rng.standard_normal(n_paths)
        diffusion = sigma * np.sqrt(dt) * z
        # number of jumps this step ~ Poisson(lam * dt)
        n_jumps = rng.poisson(lam * dt, n_paths)
        # total jump = sum of n_jumps normal draws = Normal(n*m, n*delta^2)
        jump = (rng.normal(0.0, 1.0, n_paths) * jump_std * np.sqrt(n_jumps)
                + n_jumps * jump_mean)
        log_paths[:, t] = log_paths[:, t-1] + drift + diffusion + jump
    return np.exp(log_paths)

paths = simulate_merton(S0=100, mu=0.07, sigma=0.18,
                        lam=1.0, jump_mean=-0.10, jump_std=0.07)
daily_ret = np.diff(np.log(paths), axis=1).ravel()
from scipy.stats import kurtosis, skew
print(f"excess kurtosis: {kurtosis(daily_ret):.2f}")  # >> 0, unlike GBM
print(f"skew:            {skew(daily_ret):.2f}")       # negative

Set lam=1 and jump_mean=-0.10 and you get roughly one ~10% downward shock per year on average, scattered randomly — which produces the negative skew and fat tails that match equity indices far better than GBM. This dovetails with Monte Carlo simulation for risk: swapping a GBM engine for a jump-diffusion one is often the single most impactful upgrade to a tail-risk model.

Calibration intuition

Merton has five parameters: sigma (diffusion vol), lambda (jump frequency), m and delta (jump size mean and dispersion), plus drift. There are two regimes for estimating them, and confusing the two is a classic error:

• Physical (P) measure — from historical returns. Fit the parameters to the

realized return distribution, typically by maximum likelihood on the Poisson-normal mixture or by matching moments (the empirical variance, skew, and kurtosis pin down combinations of the parameters). This tells you how the asset has actually behaved.

• Risk-neutral (Q) measure — from option prices. Calibrate by minimizing the

pricing error against the observed option surface. This recovers the parameters the market is using to price crash insurance, which generally imply more frequent and larger downward jumps than history alone — the jump-risk premium.

A practical moment-matching starting point ties the empirical moments to the parameters:

Empirical feature	Primarily driven by	Calibration lever
Overall variance	sigma + jump variance	raise sigma or lambda*delta^2
Negative skew	mean jump size m < 0	make m more negative
Excess kurtosis	jump intensity + size dispersion	lower lambda, larger jumps (rarer/bigger)
Option skew steepness	risk-neutral jump fear	calibrate m, lambda to OTM puts

The identification subtlety: a given level of kurtosis can be produced by frequent small jumps or rare large jumps, and these have very different risk implications. Frequent small jumps look almost like extra diffusion; rare large jumps are genuine tail risk you cannot hedge away. Pinning this down requires either a long sample or the option surface, and it is why historical-only calibration of jump models is notoriously unstable. Tie this back to measuring volatility: realized vol alone cannot distinguish these cases.

Implications for options and risk

Jumps change the economics of options and hedging in ways that GBM completely misses:

• The smile is a feature, not noise. Jump risk makes OTM puts genuinely worth

more, so the volatility skew is the market's rational price of discontinuity, not a model error to be smoothed away.

• Delta hedging cannot be complete. Under GBM you can in principle hedge an option

perfectly with continuous rebalancing. With jumps the market is incomplete — you cannot hedge a gap with the underlying alone, because the gap happens faster than you can rebalance. There is an irreducible residual risk that must be priced.

• Short-gamma books carry jump risk. Anyone short options (market makers, vol

sellers) is implicitly short jumps. The diffusion P&L can look flat while a single jump wipes out months of premium — the convexity bites discontinuously. This is the mechanism behind every "picking up pennies in front of a steamroller" blowup.

• Tail risk is structurally underestimated by Gaussian models. A VaR or stress

engine built on normal returns will under-reserve. Replacing the return generator with a jump-diffusion (or fitting a fat-tailed distribution directly) is the honest fix.

The deepest practical lesson: GBM tells you the market is complete and risk is

hedgeable. Jump-diffusion tells you neither is true. That single shift — from

"risk can be hedged away" to "there is a residual jump risk that must be held and

paid for" — is the whole reason the model matters for a trading desk.

Failure modes and honest limits

Jump-diffusion is a better model, not a true one. Its own pitfalls:

• Parameter instability. Jump frequency and size are estimated from a handful of

tail events in any realistic sample, so estimates are noisy and regime-dependent. Do not over-trust precise calibrated values.

• Overfitting the surface. Richer models (stochastic vol plus jumps, e.g. Bates)

fit option surfaces beautifully but can overfit; more parameters mean more ways to match noise. The fit quality is not evidence of predictive power.

• Constant-intensity unrealism. Merton assumes jumps arrive at a constant rate.

In reality jumps cluster (volatility-of-volatility, contagion) — Hawkes self-exciting processes capture this but add complexity.

• Stationarity of jumps. The jump distribution shifts with regime; a model

calibrated in calm markets understates crisis jump risk, the same trap that bites stress testing.

Conclusion

Jump-diffusion models exist because the two foundational assumptions of GBM — continuous paths and normal returns — are both false in the ways that matter most for risk. Merton's compound-Poisson jumps produce the fat tails, negative skew, and volatility smile that real markets exhibit, and they reveal the uncomfortable truth that markets with jumps are incomplete: gap risk cannot be hedged away and must be priced and held. Use jump-diffusion to build honest tail-risk engines, to understand why short-gamma books blow up discontinuously, and to interpret the option skew as rational crash pricing rather than noise. But respect its limits — jump parameters are estimated from a few rare events, they cluster and shift with regime, and richer variants overfit easily. The model is grounded in the same stochastic processes as GBM; it simply stops pretending the world is continuous.