Delta hedging error, a Monte Carlo on gamma

1. A short call, and what one day of hedging earns

Short one call and hold delta shares against it. Rebalance at the start of the day and leave the position alone until the next morning. Over that day the book makes the change in the hedge minus the change in the option, plus one day of interest on the cash account. Buying delta shares costs more than the premium brings in, so that balance is negative and the interest is a cost:

Expanding the option price to second order shows where the money goes. Delta cancels by construction, interest on the cash cancels the part of theta that comes from the rate, and what survives is gamma against the size of the move:

A quiet day, with a move smaller than one expected daily standard deviation, leaves the book ahead: it collects the time decay. A large move in either direction costs money, and that loss grows with the square of the move. Both sides are multiplied by gamma, so wherever gamma is large the day swings hard, and wherever gamma is close to zero the hedge is close to perfect.

2. Black-Scholes price, delta and gamma

Three functions carry the whole model. Price values the call, delta sets the number of shares held, and gamma is only used to explain the results. Parameters sit at the top of the script so a single edit changes volatility, the rate, the option's life or the number of paths.

parameters

SIGMA = 0.18            # implied vol, and realised vol, annualised
S0 = K = 100.0          # the call starts exactly at the money
R = 0.02                # flat risk-free rate: prices drift at it and the hedge's cash pays it
DT = 1 / 252            # one trading day
LIFE_DAYS = 20          # the option is sold 20 trading days before expiry
N_PATHS = 150_000
SEED = 11

black_scholes.py

def d1(S, K, T, sig):
    return (np.log(S / K) + (R + 0.5 * sig ** 2) * T) / (sig * np.sqrt(T))


def call_price(S, K, T, sig):
    a = d1(S, K, T, sig)
    return S * norm.cdf(a) - K * np.exp(-R * T) * norm.cdf(a - sig * np.sqrt(T))


def call_delta(S, K, T, sig):
    return norm.cdf(d1(S, K, T, sig))


def gamma(S, K, T, sig):
    return norm.pdf(d1(S, K, T, sig)) / (S * sig * np.sqrt(T))

3. Simulating 150,000 price paths

Two independent draws per path do the work. Z1 decides where spot has wandered by the morning in question, and Z2 decides the move during that day. Both are drawn once and reused at every maturity, a technique called common random numbers. Comparing 10 days to expiry with 1 day therefore compares time and nothing else, because the randomness underneath is identical.

Prices drift at the risk-free rate and realised volatility equals implied volatility, so the hedge is right on average. Any profit or loss that appears below is discretisation error, meaning the price of adjusting the hedge once a day instead of continuously.

one_day_of_hedging.py

rng = np.random.default_rng(SEED)
Z1 = rng.standard_normal(N_PATHS)      # where spot has wandered to by the start of the day
Z2 = rng.standard_normal(N_PATHS)      # the move during that one day


def one_day_of_hedging(tau_days):
    """P&L of a short call hedged with delta shares over one day, starting tau_days before expiry.

    Z1 and Z2 are reused for every tau, common random numbers, so results at different
    maturities differ because of time and nothing else. Buying delta shares uses more cash than
    the premium brings in, so the cash balance is negative and pays interest over the day.
    """
    elapsed = (LIFE_DAYS - tau_days) * DT
    s = S0 * np.exp((R - 0.5 * SIGMA ** 2) * elapsed + SIGMA * np.sqrt(elapsed) * Z1)
    s_next = s * np.exp((R - 0.5 * SIGMA ** 2) * DT + SIGMA * np.sqrt(DT) * Z2)
    t0, t1 = tau_days * DT, (tau_days - 1) * DT
    c0 = call_price(s, K, t0, SIGMA)
    c1 = np.maximum(s_next - K, 0.0) if t1 <= 1e-9 else call_price(s_next, K, t1, SIGMA)
    hedge = call_delta(s, K, t0, SIGMA)
    cash = c0 - hedge * s                              # premium in, shares bought, negative
    pnl = -(c1 - c0) + hedge * (s_next - s) + cash * np.expm1(R * DT)
    return s / K, pnl

4. What one day of hedging looks like

Every dot is one path: where spot sat relative to the strike that morning, and what the hedged position made or lost by the next one. Ten trading days before expiry the cloud is a wide, flat band. On the last day it collapses into a sharp shape centred on the strike.

Two features give the shape away. Gains have a hard ceiling: if spot does not move at all, the best a short option can do is keep one day of time value, less a day of interest on the hedge. Losses have no floor, since a large move costs gamma times its square. Both are measured below against theory.

Simulated ceilings land within 0.0003 of theory at every maturity, which is the check that the engine is doing what the formula says. On the last day the ceiling reaches $0.45, nearly the entire remaining value of the option, because a call worth $0.46 that finishes exactly at the strike expires worthless, and only a day of interest on the hedge comes off. Average P&L stays at zero throughout, as it should when realised and implied volatility are equal. Worst days deepen from −$1.56 to −$2.66 as expiry approaches.

5. Spread of the error, by moneyness

A scatter shows the shape. A number needs the spread. Paths are grouped by where spot started the day relative to the strike, and the standard deviation of one day's P&L is taken inside each group. np.bincount does it without a Python loop, which matters at 150,000 paths. Groups with fewer than 900 paths are left blank so that thin tails do not draw false spikes.

spread_by_moneyness.py

EDGES = np.linspace(0.94, 1.06, 49)
CENTRES = (EDGES[:-1] + EDGES[1:]) / 2
AT_STRIKE = int(np.argmin(np.abs(CENTRES - 1.0)))


def spread_by_moneyness(m, pnl, min_count=900):
    idx = np.digitize(m, EDGES) - 1
    ok = (idx >= 0) & (idx < len(CENTRES))
    n = np.bincount(idx[ok], minlength=len(CENTRES)).astype(float)
    s1 = np.bincount(idx[ok], weights=pnl[ok], minlength=len(CENTRES))
    s2 = np.bincount(idx[ok], weights=pnl[ok] ** 2, minlength=len(CENTRES))
    with np.errstate(invalid="ignore", divide="ignore"):
        std = np.sqrt(np.maximum(s2 / n - (s1 / n) ** 2, 0.0))
    std[n < min_count] = np.nan
    return std

At the strike, the spread grows 3.4 times between 10 days and the last day. Square root of time predicts 3.16 times, because gamma scales with one over the square root of time to expiry. Simulation lands slightly above that on the final day, where a one day step equals the whole remaining life of the option and the small step approximation behind the square root rule stops holding. Five percent away from the strike on that same day, the spread falls to 0.0000015: gamma is essentially zero there, and a delta hedge is essentially perfect.

6. Error as a share of the option

$0.346 on its own says little. Measured against what the option is actually worth, it becomes the most important number on the page. Three things move at the strike as expiry approaches, and they move in opposite directions.

Gamma rises by the square root of ten, 3.16 times, while the option's value falls by about the same factor, to 0.31 of where it started. Hedge error follows gamma, so its share of the option grows by roughly ten times, from 7% of the premium to 76%. One day of ordinary hedging noise on the last day is worth three quarters of everything the option still carries.

That share does not depend on the level of volatility. Error scales with gamma times volatility squared, gamma scales with one over volatility, and the option's value scales with volatility, so volatility cancels. Only the ratio of the hedging interval to the time left matters, which is why the last day is so much worse than any other.

7. Buying the error back by hedging more often

If gamma is the problem, frequency is the tool. Splitting the final day into N rebalances shrinks each move between adjustments, and the spread of P&L falls with the square root of N. Each path below starts the last morning exactly at the strike, which is the worst place to be.

last_day_rebalanced.py

def last_day_rebalanced(n_rebalances, paths=200_000, seed=3):
    """Final day only, spot opening exactly at the strike, delta rebalanced n times in the day."""
    g = np.random.default_rng(seed)
    h = DT / n_rebalances
    s = np.full(paths, K)
    cash = np.full(paths, float(call_price(K, K, DT, SIGMA)))     # premium received
    shares = np.zeros(paths)
    for i in range(n_rebalances):
        hedge = call_delta(s, K, DT - i * h, SIGMA)
        cash -= (hedge - shares) * s                               # buy or sell the difference
        shares = hedge
        s = s * np.exp((R - 0.5 * SIGMA ** 2) * h + SIGMA * np.sqrt(h) * g.standard_normal(paths))
        cash *= np.exp(R * h)                                      # interest until the next rebalance
    pnl = cash + shares * s - np.maximum(s - K, 0.0)               # close the book at expiry
    return float(pnl.std()), float(pnl.mean())

Matching the accuracy that one rebalance a day delivered at 10 days to expiry takes 12 rebalances on the last day, roughly every 32 minutes, which brings the spread to $0.110. Every five minutes cuts it to $0.044. Simulation follows the one over square root of N rule closely at every step.

That is exactly the trade a market maker lives with. Every rebalance crosses a bid ask spread, and at the strike on expiry day delta swings the most, so the hedge needs the most adjustments precisely where each adjustment costs the most. Holding gamma into the close means choosing between hedging noise and transaction costs, and neither one goes away.

8. Limitations

• Geometric Brownian motion has no jumps and no fat tails. Real returns have both, so the loss tail on a real book is longer and bad days arrive more often than here.
• Realised volatility equals implied. In markets implied volatility usually sits above what is later realised, so option sellers earn a small positive average. This setup removes that premium on purpose, to isolate the error.
• No transaction costs and no bid ask spread. They would bite hardest exactly where section 7 says rebalancing matters most.
• Constant volatility, no skew, a flat 2% rate. Financing the roughly half a share held per option costs about $0.0040 a day at that rate, against more than 30 cents of hedging error at the strike on the last day. Interest also cancels the rate part of theta, so a different rate would not move any conclusion.
• One option, one strike, a fixed rebalance time. Real books net gamma across many strikes and expiries, and assignment and pin mechanics at the close are not modelled.
• Dots bunch near the strike in section 4 because every path starts there, which makes the scatter look more concentrated than the effect alone. Section 5 measures spread inside each bucket and does not depend on how many dots land where.

Summary

Delta hedging works best where it is needed least. Away from the strike, or with plenty of time left, one rebalance a day leaves a small and predictable error. At the strike in the final days, gamma rises while the option shrinks, and a hedge that looked adequate a week earlier becomes noise worth most of the premium. Rebalancing more often buys it back, at a cost that grows in the same place.

Related

• Advanced option greeks in Python, on a live chain
• Gamma surface
• Deep hedging
• Black-Scholes model