Greeks and Delta Hedging

Finance

The Black-Scholes formula tells you what an option is worth. The GREEKS — its derivatives with respect to each input — tell you what to do about it. They are the day-to-day language of options trading: every position has a delta (linear exposure to the underlying), a gamma (how delta moves as the underlying moves), a vega (sensitivity to volatility), a theta (decay over time), and a rho (rate sensitivity). Risk managers track them across the firm's book; market makers hedge them; volatility traders bet on them. Pricing an option is the first step; understanding its Greeks and using them to construct a hedge is the rest of the job.

The Greeks of a European call

For a European call $C (S, K, T, r, σ) = S Φ (d_{1}) - K e^{- r T} Φ (d_{2})$ with

d_{1} = \frac{ln ( S / K ) + ( r + \frac{1}{2} σ ^{2} ) T}{σ T}, d_{2} = d_{1} - σ T,

direct differentiation gives closed forms for all five Greeks:

Delta: $Δ = \partial C / \partial S = Φ (d_{1})$ . Number of shares of the underlying needed to hedge one option. For a call, $0 \leq Δ \leq 1$ ; deep in-the-money calls have $Δ \to 1$ (behaves like stock), deep out-of-the-money have $Δ \to 0$ .
Gamma: $Γ = \partial^{2} C / \partial S^{2} = ϕ (d_{1}) / (S σ T)$ . Curvature; how quickly delta moves when the stock does. Long options are LONG GAMMA — delta increases as stock rises, decreases as it falls, so re-hedging buys low and sells high. Short options are short gamma and re-hedging does the reverse.
Vega: $V = \partial C / \partial σ = Sϕ (d_{1}) T$ . Sensitivity to implied volatility. Long options have positive vega.
Theta: $Θ = \partial C / \partial t$ . Time decay; for a long call, negative (option loses value as expiry approaches, all else equal). Quoted per day in practice.
Rho: $ρ = \partial C / \partial r = K T e^{- r T} Φ (d_{2})$ . Sensitivity to the risk-free rate. Less important for short-dated options; central for long-dated ones (FX, rates, very-long-dated equity).

The Black-Scholes PDE and the Greek relationship

The Greeks aren't independent — they satisfy the Black-Scholes PDE,

Θ + \frac{1}{2} σ^{2} S^{2} Γ + r S Δ - r C = 0.

A delta-hedged position ( $Δ = 0$ ) has its P&L driven by THETA against GAMMA: short an option is short gamma, you collect theta but lose money on every rebalance because gamma is negative. Long an option is long gamma, you pay theta but make money rebalancing (buying when stock falls, selling when it rises). The fundamental theorem of options trading reduces to "balance gamma and theta correctly." This is also why option market makers track gamma exposure carefully — that's their daily P&L driver after delta is hedged.

Delta hedging in practice

The textbook story: hold a SHORT position in $Δ$ shares of the underlying against a LONG option. As $S$ moves, $Δ$ changes, and you rebalance the hedge. In CONTINUOUS-TIME Black-Scholes theory, this strategy replicates the option exactly — the hedger's P&L converges to zero in the limit of continuous rebalancing. In practice, rebalancing happens at discrete intervals (every minute, hour, day), and the residual P&L variance comes from the GAMMA CURVATURE between rebalances. Higher rebalance frequency → smaller hedging error.

The hedging-error variance scales as $\propto 1/ n$ in the number of rebalances $n$ per option lifetime; the standard deviation as $\propto 1/ n$ . Frequent rebalancing reduces variance but increases transaction costs (every trade has a bid-ask spread and possibly impact); the optimal frequency balances the two and is the subject of a literature dating back to Leland (1985) and beyond.

Code: Greeks and hedge-error scaling

# Greeks of a European call (Black-Scholes), plus a discrete delta-hedging
# Monte Carlo simulation showing P&L variance shrinking with rebalance
# frequency.

import numpy as np
from scipy.stats import norm

def bs_call(S, K, T, r, sigma):
    if T <= 0: return max(S - K, 0)
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    return S * norm.cdf(d1) - K * np.exp(-r*T) * norm.cdf(d2)

def bs_greeks(S, K, T, r, sigma):
    """Returns delta, gamma, vega, theta, rho for a European call."""
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    delta = norm.cdf(d1)
    gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))
    vega  = S * norm.pdf(d1) * np.sqrt(T)
    theta = (-S * norm.pdf(d1) * sigma / (2*np.sqrt(T))
             - r * K * np.exp(-r*T) * norm.cdf(d2))
    rho   = K * T * np.exp(-r*T) * norm.cdf(d2)
    return delta, gamma, vega, theta, rho

# At-the-money 6-month call: S=K=100, r=3%, sigma=20%
S, K, T, r, sigma = 100.0, 100.0, 0.5, 0.03, 0.2
d, g, v, th, rh = bs_greeks(S, K, T, r, sigma)
print(f"ATM call (S=K=100, T=0.5, r=3%, sigma=20%):")
print(f"  Price = {bs_call(S,K,T,r,sigma):.4f}")
print(f"  Delta = {d:.4f}    Gamma = {g:.6f}")
print(f"  Vega  = {v:.4f}    Theta = {th:.4f}/year   Rho = {rh:.4f}")

# Sanity check via finite differences
eps = 1e-4
delta_fd = (bs_call(S+eps,K,T,r,sigma) - bs_call(S-eps,K,T,r,sigma)) / (2*eps)
gamma_fd = (bs_call(S+eps,K,T,r,sigma) - 2*bs_call(S,K,T,r,sigma)
            + bs_call(S-eps,K,T,r,sigma)) / eps**2
vega_fd  = (bs_call(S,K,T,r,sigma+eps) - bs_call(S,K,T,r,sigma-eps)) / (2*eps)
print(f"\nFD verification:")
print(f"  |delta - delta_fd| = {abs(d-delta_fd):.2e}")
print(f"  |gamma - gamma_fd| = {abs(g-gamma_fd):.2e}")
print(f"  |vega  - vega_fd|  = {abs(v-vega_fd):.2e}")

# Discrete delta hedging: sell a call, rebalance hedge n times, replicate.
def delta_hedge_pnl(n_rebalance, n_paths=2000, T=0.5, S0=100.0, K=100.0,
                    r=0.03, sigma=0.2, seed=42):
    rng = np.random.default_rng(seed)
    dt = T / n_rebalance
    C0 = bs_call(S0, K, T, r, sigma)
    final_pnl = np.zeros(n_paths)
    for i in range(n_paths):
        S = S0
        cash = C0          # received from selling the call
        delta_prev = 0.0
        for k in range(n_rebalance):
            tau = T - k*dt
            d_now, *_ = bs_greeks(S, K, tau, r, sigma)
            cash -= (d_now - delta_prev) * S      # buy/sell to match new delta
            cash *= np.exp(r*dt)                  # cash earns r
            delta_prev = d_now
            z = rng.standard_normal()
            S *= np.exp((r - 0.5*sigma**2)*dt + sigma*np.sqrt(dt)*z)
        cash += delta_prev * S                    # liquidate shares
        cash -= max(S - K, 0)                     # pay option payoff
        final_pnl[i] = cash
    return final_pnl

print(f"\nDiscrete delta hedging — P&L distribution:")
print(f"  {'rebalances':>12s}  {'P&L mean':>10s}  {'P&L std':>10s}")
for n in [4, 16, 64, 256]:
    pnl = delta_hedge_pnl(n)
    print(f"  {n:>12d}  {np.mean(pnl):>10.4f}  {np.std(pnl):>10.4f}")
print("Std shrinks ~1/sqrt(n): the continuous-rebalancing limit replicates exactly.")

Output:

ATM call (S=K=100, T=0.5, r=3%, sigma=20%):
  Price = 6.3710
  Delta = 0.5702    Gamma = 0.027772
  Vega  = 27.7721    Theta = -7.0738/year   Rho = 25.3224

FD verification:
  |delta - delta_fd| = 1.91e-11
  |gamma - gamma_fd| = 1.42e-07
  |vega  - vega_fd|  = 4.48e-08

Discrete delta hedging — P&L distribution:
    rebalances    P&L mean     P&L std
             4     -0.0288      2.3533
            16     -0.0205      1.1850
            64     -0.0262      0.6179
           256     -0.0080      0.3078
Std shrinks ~1/sqrt(n): the continuous-rebalancing limit replicates exactly.

Three things to read off. (1) The analytical Greeks match finite-difference verification to $\sim 1 0^{- 7}$ — the closed forms are correct. (2) The ATM 6-month call costs $6.37 with delta 0.57 — the hedge requires going short 0.57 shares per call, financing the cash from the option sale. (3) Hedging P&L variance shrinks as predicted: std drops from 2.35 with 4 rebalances per option lifetime to 0.31 with 256 — roughly a $64 = 8 \times$ reduction for a $64 \times$ increase in rebalance frequency, matching the $1/ n$ scaling.

What an options book actually looks like

A real options trading book doesn't hold ONE option — it holds thousands across many strikes and expiries, with the Greeks AGGREGATED. The total delta, total gamma, total vega become single numbers risk-managed against limits. A market maker's typical day:

Wake up: book has some $Δ, Γ, V$ from yesterday's positions plus overnight option creation/destruction.
Open: hedge the delta by trading the underlying (futures, ETF, basket). Aim for delta-neutral going into the session.
Through the day: trade options, accumulating positions. Re-hedge delta whenever it drifts past a tolerance threshold (typically a few hundred to a few thousand shares of underlying-equivalent).
Manage gamma and vega: long gamma is desirable (you benefit from re-hedging), but it costs you theta. Vega is bet directionally if you have a view on implied vol, otherwise hedged with vol products.
Close: square delta back to flat overnight if possible; record P&L attributed to theta (collected/paid), gamma (re-hedging gains/losses), vega (vol changes), and basis (mispricing of the underlying hedge).

Beyond Black-Scholes

Real markets have features Black-Scholes doesn't predict: $σ$ depends on strike (volatility surfaces), jumps in the stock, stochastic volatility, transaction costs, discrete dividends. Each gives rise to its own Greeks and hedging considerations:

Vanna $= \partial Δ/ \partial σ$ : how delta moves when vol moves. Important for option books with vol exposure.
Volga $= \partial V / \partial σ$ : convexity in vol. Critical for vol-of-vol exposure (e.g. volatility swaps).
Charm $= \partial Δ/ \partial t$ : delta decay; matters for overnight hedging.
Speed $= \partial^{3} C / \partial S^{3}$ : rate of gamma change; relevant for large gamma positions where second-order corrections matter.

Black-Scholes model — the foundational pricing formula.
Volatility surfaces & calibration — what real-world Greeks have to deal with.
Monte Carlo option pricing — how the Greeks are computed for path-dependent and exotic options.
Implied volatility — the inverse of the Black-Scholes formula, used to quote vol-by-strike.