Delta Hedging: What It Really Costs to Replicate an Option

import numpy as np
from math import erf, exp, log, sqrt

S0, K, T, sigma = 100.0, 100.0, 0.25, 0.20
N = lambda x: 0.5 * (1 + erf(x / sqrt(2)))

def delta(S, t):
    if t <= 1e-9:
        return 1.0 if S > K else 0.0
    d1 = (log(S / K) + 0.5 * sigma ** 2 * t) / (sigma * sqrt(t))
    return N(d1)

rng = np.random.default_rng(5)

def replication_error(steps):
    dt = T / steps
    S, pos = S0, delta(S0, T)
    cash = -pos * S0
    for i in range(1, steps + 1):
        S *= exp(-0.5 * sigma ** 2 * dt + sigma * sqrt(dt) * rng.standard_normal())
        d = delta(S, T - i * dt)
        cash -= (d - pos) * S
        pos = d
    return pos * S + cash - max(S - K, 0)

for n in (4, 52):
    errs = [replication_error(n) for _ in range(200)]
    print(f"rehedge {n:>2}x over the option's life: error sd {np.std(errs):.2f} per option")

print()
print("hedging more often shrinks the error - but every rebalance costs money")