Chapter 19 — Greeks and Hedging
"Delta is the map; Gamma is the terrain. Trade without knowing gamma and you'll fall off a cliff."
After this chapter you will be able to:
- Explain the five primary Greeks in plain English before reaching for a formula
- Aggregate Greeks across a book of options weighted by notional
- Derive and interpret the gamma-theta identity $\Theta = -\frac{1}{2}\sigma^2 S^2 \Gamma$ and understand what it means about the fundamental tradeoff in long-option positions
- Compute the daily P&L of a delta-hedged position and relate it to realised vs implied volatility
- Construct delta-vega neutral hedges using two liquid options as instruments
- Describe the practical frictions of delta hedging and how real market makers manage their books
A market maker who sells an option to a client takes on a position with a complex, nonlinear risk profile. She cannot simply look at the option's price and decide whether her book is safe. She needs to know: How much does this position lose if the underlying moves by \$1? By \$10? If volatility increases by 1%? If time passes by one day? These are the Greeks, and for a desk running hundreds of positions across multiple underlyings and expiries, the aggregate Greeks of the entire book are the operational heartbeat of risk management.
Chapter 10 defined the Greeks for individual options: delta ($\partial V/\partial S$), gamma ($\partial^2 V/\partial S^2$), vega ($\partial V/\partial \sigma$), theta ($\partial V/\partial t$), and rho ($\partial V/\partial r$). This chapter promotes that analysis from the single-option level to the portfolio level. The central result is that Greeks aggregate linearly across positions: the book's delta is the sum of position deltas, weighted by notional. This additivity enables the construction of hedges — additional positions in liquidly-traded instruments that offset the Greeks of the entire book to within target tolerances.
The deepest insight in this chapter is the P&L decomposition of a delta-hedged book. A delta-neutral long-gamma position does not sit still — it profits from every large move in the underlying, in either direction. But it pays for this through theta decay: every day that passes, the book loses the time value of its options. The famous identity $\Theta = -\frac{1}{2}\sigma^2 S^2 \Gamma$ quantifies the tradeoff. Long gamma earns on large moves, short gamma earns on small (quiet) market days. Trading volatility with gamma is the core activity of an options market maker.
19.1 The Six Greeks in Plain English
Before working with formulas, it is worth understanding what each Greek means intuitively to a trader.
Delta ($\Delta$): The equity-equivalent exposure. A long call with delta 0.50 behaves like holding 50 shares of a 100-share position. If the stock rises by \$1, the call gains approximately $0.50. Delta is the most operationally important Greek because it determines the stock hedge needed to neutralise directional risk.
Gamma ($\Gamma$): The rate of change of delta. A long option position has positive gamma: as the stock rises, delta increases, so you "buy along the trend." A short option has negative gamma: delta declines as the stock rises, meaning you "fight the trend." Gamma is why options are nonlinear. A position with gamma = 0.02 means that delta changes by 0.02 for each \$1 move in the stock. For a large position, this creates compounding P&L on directional moves.
Theta ($\Theta$): Time decay. Every day that passes, the time value of an option erodes. For a long option position, theta is negative (you lose daily even if nothing moves). Theta is often expressed in dollars per day. A long ATM option on a \$100 stock with vol = 20% and 3 months to expiry has theta of approximately $-0.03$ per share per day — for a 100-share position, time decay costs about \$3/day.
Vega ($\mathcal{V}$): Sensitivity to implied volatility. A long option position has positive vega: if implied vol rises by 1 percentage point, the option becomes more valuable. Vega is not a "Greek" in the strict calculus sense (implied volatility is not a state variable of the Black-Scholes model) but it is essential for managing implied-vol risk. A desk with large vega exposure can be dramatically affected by vol re-pricing events even if the underlying doesn't move.
Rho ($\rho$): Interest rate sensitivity. For shorter-dated vanilla options, rho is small and often ignored. For long-dated options, rho matters more — a 2-year call on a stock with $r = 5%$ has meaningful exposure to rate moves. Rho also matters for currency options and options on bonds.
Vanna and Volga: Second-order sensitivities to the cross of spot and vol (vanna = $\partial \Delta / \partial \sigma = \partial \mathcal{V} / \partial S$) and the squared vol (volga = $\partial \mathcal{V} / \partial \sigma$). These matter for skewed or smile-sensitive positions and are essential for trading barrier options or structures with strong vol-spot correlation.
The key operational result: all Greeks are additive across positions. A book of 500 different option positions has a single net delta, single net gamma, etc. This additivity is what makes portfolio-level risk management tractable.
19.2 The Greek Alphabet of Risk — Portfolio Aggregation
We saw the individual Greeks in Chapter 10. Here we focus on managing them in a portfolio.
module Option_book = struct
type position = {
underlying : string;
option_type : [`Call | `Put];
exercise : [`European | `American];
strike : float;
expiry : float; (* years to expiry *)
notional : float; (* number of options, negative = short *)
spot : float;
vol : float;
rate : float;
div_yield : float;
}
type greeks = {
delta : float;
gamma : float;
theta : float;
vega : float;
rho : float;
vanna : float;
volga : float;
}
let compute_greeks pos =
let module G = Black_scholes.Greeks in
let args = pos.spot, pos.strike, pos.rate, pos.div_yield, pos.vol, pos.expiry in
let g = G.all args pos.option_type in
let n = pos.notional in
{ delta = n *. g.G.delta;
gamma = n *. g.G.gamma;
theta = n *. g.G.theta;
vega = n *. g.G.vega;
rho = n *. g.G.rho;
vanna = n *. g.G.vanna;
volga = n *. g.G.volga }
let aggregate_greeks positions =
let gs = List.map compute_greeks positions in
List.fold_left (fun acc g -> {
delta = acc.delta +. g.delta;
gamma = acc.gamma +. g.gamma;
theta = acc.theta +. g.theta;
vega = acc.vega +. g.vega;
rho = acc.rho +. g.rho;
vanna = acc.vanna +. g.vanna;
volga = acc.volga +. g.volga;
}) { delta=0.; gamma=0.; theta=0.; vega=0.; rho=0.; vanna=0.; volga=0. } gs
end
19.3 The Gamma-Theta Identity
The Black-Scholes PDE:
$$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + rS\frac{\partial V}{\partial S} - rV = 0$$
can be rewritten using Greek notation as:
$$\Theta + \frac{1}{2}\sigma^2 S^2 \Gamma + rS\Delta - rV = 0$$
For an at-the-money call with $S \approx \text{strike}$ and small $r$, the term $rS\Delta - rV$ is small relative to the other two. The dominant relationship is:
$$\Theta \approx -\frac{1}{2}\sigma^2 S^2 \Gamma$$
This is the gamma-theta identity, and it is the most important identity in options trading. It says:
- Long gamma ($\Gamma > 0$, which applies to any long option position) forces negative theta ($\Theta < 0$). You are paying time decay as the price of owning gamma.
- Short gamma ($\Gamma < 0$, short option position) means positive theta ($\Theta > 0$). You collect time decay as the premium for selling gamma.
The intuition is powerful: when you buy an option, you pay for the right to profit from large moves. The option's time value represents that right. Every day that passes without a large move, the right is worth less. Theta is the daily cost you pay for maintaining that right.
Magnitude: For an ATM call on a \$100 stock with $\sigma = 20%$, $\tau = 0.25$ years, and $\Gamma \approx 0.04$ per share:
$$|\Theta| \approx \frac{1}{2} \times (0.20)^2 \times 100^2 \times 0.04 / 365 \approx $0.022\text{ per share per day}$$
So for a 1,000-share position (long 10 contracts), you lose approximately \$22/day in time decay. This is the cost of maintaining the long-gamma, long-vol position.
The volatility trader's P&L: Consider a delta-hedged long call held for one day. The stock moves from $S$ to $S + \delta S$ and you rebalance the delta hedge. The P&L from the option itself is approximately $\Delta \cdot \delta S + \frac{1}{2}\Gamma (\delta S)^2$ (the delta term is cancelled by the hedge). The net P&L is:
$$\Pi_{\text{day}} \approx \frac{1}{2}\Gamma (\delta S)^2 + \Theta \cdot \Delta t \approx \frac{1}{2}\Gamma (\delta S)^2 - \frac{1}{2}\sigma_{\text{impl}}^2 S^2 \Gamma \cdot \Delta t$$
If we write $(\delta S)^2 \approx \sigma_{\text{realised}}^2 S^2 \Delta t$ (which holds on average), then:
$$\Pi_{\text{day}} \approx \frac{1}{2}\Gamma S^2 (\sigma_{\text{realised}}^2 - \sigma_{\text{implied}}^2) \Delta t$$
This is the fundamental P&L equation of volatility trading: a delta-hedged long call makes money if and only if realised volatility during the holding period exceeds the implied volatility at which the option was purchased. It loses money when realised vol falls short of implied vol. The options dealer selling a call at $\sigma_{\text{impl}} = 25%$ is betting that the market will actually realise less than 25% vol — and she will collect theta for every quiet day.
19.4 Delta Hedging — Practice
A delta-hedged portfolio rebalances to maintain zero delta. The simulation below tracks the P&L from gamma and theta over a stock price path, allowing us to verify the gamma-theta P&L formula above.
Figure 19.1 — Cumulative P&L of an unhedged long call versus a delta-hedged portfolio. Delta hedging neutralises the directional exposure to the underlying asset price, leaving a much smaller risk profile driven primarily by gamma and theta.
In practice, delta hedging is never truly continuous. Discrete rebalancing introduces hedging errors: the hedger is approximately delta-neutral between rebalance times, but the convexity of the option means that large moves between rebalancing create additional gamma-related P&L. In real markets, additional frictions include:
- Bid-ask spread: every delta hedge trade crosses the spread. A market maker hedging delta hourly on a liquid stock might pay \$0.01/share spread on each hedge trade. For a 10,000-share notional hedged 4 times per day, this is \$400/day in transaction costs alone.
- Market impact: large delta hedge trades in less liquid markets can move the price, increasing the cost of hedging.
- Discrete rebalancing error: rebalancing only once per day means the hedge is imperfect for all intra-day moves. This introduces a systematic difference between the "theoretical" P&L (continuous delta hedging) and the actual P&L.
- Spot-vol correlation (vanna): in a market with a vol smile, delta itself changes as implied vol moves. The "correct" delta to hedge should account for how implied vol changes when the spot moves — leading to the "sticky-smile" vs "sticky-moneyness" delta debate.
The BLS replication error for a dollar-delta-hedged call is:
$$d\Pi = \frac{1}{2}\Gamma S^2 (\sigma_{\text{realised}}^2 - \sigma_{\text{implied}}^2) dt$$
module Delta_hedge = struct
(** Simulate delta-hedged P&L over a path *)
let simulate ~position ~path ~dt ~rebalance_freq =
let n_steps = Array.length path - 1 in
let hedge = ref 0.0 in (* number of shares held *)
let cash = ref 0.0 in
let pnl = ref 0.0 in
let tau = ref position.Option_book.expiry in
for t = 0 to n_steps - 1 do
let s = path.(t) in
(* Current delta *)
let pos = { position with Option_book.spot = s;
Option_book.expiry = !tau } in
let new_delta = (Option_book.compute_greeks pos).Option_book.delta in
(* Rebalance every rebalance_freq steps *)
if t mod rebalance_freq = 0 then begin
let trade = new_delta -. !hedge in
cash := !cash -. trade *. s; (* buy/sell shares *)
hedge := new_delta
end;
(* Apply interest on cash *)
cash := !cash *. exp (position.Option_book.rate *. dt);
tau := !tau -. dt
done;
(* Final P&L: option payoff - hedge value *)
let s_t = path.(n_steps) in
let payoff = match position.Option_book.option_type with
| `Call -> Float.max 0.0 (s_t -. position.Option_book.strike)
| `Put -> Float.max 0.0 (position.Option_book.strike -. s_t)
in
pnl := payoff -. !hedge *. s_t +. !cash;
!pnl
(** Gamma scalping: profit from each rebalancing trade on a long-gamma position.
Each time the stock moves significantly, the hedge must be adjusted,
and the P&L from that adjustment captures realised volatility vs theta cost. *)
let gamma_scalp_pnl_attribution ~position ~path ~dt =
let n_steps = Array.length path - 1 in
let hedge = ref 0.0 in
let tau = ref position.Option_book.expiry in
let theta_total = ref 0.0 in
let gamma_total = ref 0.0 in
let results = Array.init n_steps (fun t ->
let s0 = path.(t) in
let s1 = path.(t + 1) in
let ds = s1 -. s0 in
let pos = { position with Option_book.spot = s0; Option_book.expiry = !tau } in
let g = Option_book.compute_greeks pos in
let new_delta = g.Option_book.delta in
let gamma_pnl = 0.5 *. g.Option_book.gamma *. ds *. ds in
let theta_pnl = g.Option_book.theta *. dt in
gamma_total := !gamma_total +. gamma_pnl;
theta_total := !theta_total +. theta_pnl;
ignore (hedge := new_delta);
tau := !tau -. dt;
(gamma_pnl, theta_pnl)
) in
Printf.printf "Gamma scalping attribution over %d steps:\n" n_steps;
Printf.printf " Total gamma P&L: %.4f\n" !gamma_total;
Printf.printf " Total theta decay: %.4f\n" !theta_total;
Printf.printf " Net P&L: %.4f\n" (!gamma_total +. !theta_total);
results
end
The gamma_scalp_pnl_attribution function separates the daily gamma P&L ($\frac{1}{2}\Gamma (\delta S)^2$) from the daily theta decay ($\Theta \cdot \delta t$). Over a sufficiently long sample, the gamma P&L is proportional to realised variance and the theta is proportional to implied variance — confirming the volatility trading P&L formula. This attribution is a standard diagnostic used by options desks to verify that their realised vol is tracking their theta cost.
19.5 Vega Hedging and Higher-Order Sensitivities
Delta hedging removes the first-order directional risk. But a delta-hedged options book still has exposure to implied volatility through vega. If the market reprices implied vol upward by 2 percentage points (a common move on a busy day), a book with $\mathcal{V} = +10{,}000$ (long vega) gains $10{,}000 \times 0.02 = \$200$. A book with $\mathcal{V} = -50{,}000$ loses $\$1{,}000$. Vega hedging requires adding option positions (not just stock) because the underlying has zero vega.
A vega-neutral book is immune to parallel shifts in implied vol. To construct a simultaneous delta-vega neutral hedge using two liquid options (call $C_1$ with $(\Delta_1, \mathcal{V}_1)$ and $C_2$ with $(\Delta_2, \mathcal{V}_2)$), solve the system:
$$n_1 \mathcal{V}1 + n_2 \mathcal{V}2 = -\mathcal{V}{\text{book}}$$ $$n_1 \Delta_1 + n_2 \Delta_2 = -\Delta{\text{book}} \quad \text{(stock hedge adjusts residual delta)}$$
This is a $2\times2$ linear system in $n_1, n_2$. A third instrument is required to additionally neutralise gamma or any second-order sensitivity.
Vanna and Volga capture the second-order vol sensitivities:
- Vanna = $\partial \Delta / \partial \sigma = \partial \mathcal{V} / \partial S$: how delta changes when vol moves (equivalently, how vega changes when spot moves). Relevant for barrier options and any trade where spot and vol are correlated.
- Volga = $\partial \mathcal{V} / \partial \sigma$: how vega itself changes when vol moves. Relevant for vol-of-vol risk and structures with convexity in vol.
In practice, banks run "vega bucketing" — they treat vega at different option expiries as separate risks (1-month vega, 3-month vega, 1-year vega, etc.) rather than just total vega, because the vol surface can move in non-parallel ways (e.g., short-end vol spikes without long-end vol changing). A full vega hedge across the vol surface requires a matching position at each expiry bucket.
In Practice: A market maker who sold an exotic (e.g., a 1-year barrier call) at a 25% implied vol will hedge with liquid vanilla options in the market at that same vol level. If the vol surface subsequently moves — say, short-dated vol rises to 30% while the exotic's 1-year vol remains at 25% — the market maker has a cross-expiry vega mismatch that creates P&L. This type of vol surface risk is the primary risk of exotic option dealing and is managed through a combination of vanilla option vega hedges across expiry buckets.
19.6 Risk Limits and Greeks Limits
Risk limits on Greeks are the operational mechanism by which risk managers translate the firm's risk appetite into daily trading constraints. A desk may be given, for example, a net delta limit of ±\$50,000 notional-equivalent, a gamma limit of ±\$5,000/% move, and a vega limit of ±\$100,000/vol-point. These limits reflect the desk's capital allocation, the liquidity of hedging instruments, and an assessment of how quickly positions can be closed if needed.
The check_limits function below validates the current book greeks against the limit table and returns a list of limit breaches and warnings. In a production system, this function would run every few seconds as the market moves, and a breach would typically trigger an automatic alert to the risk manager and potentially freeze trading authority until the breach is corrected.
module Risk_limits = struct
type limit = {
greek : [`Delta | `Gamma | `Vega | `Theta];
max_abs : float;
warning : float; (* threshold for alert, < max_abs *)
}
type breach = { greek: string; value: float; limit: float; is_warning: bool }
let check_limits book_greeks limits =
let get_greek g = match g with
| `Delta -> book_greeks.Option_book.delta
| `Gamma -> book_greeks.Option_book.gamma
| `Vega -> book_greeks.Option_book.vega
| `Theta -> book_greeks.Option_book.theta
in
let name_of = function
| `Delta -> "Delta" | `Gamma -> "Gamma"
| `Vega -> "Vega" | `Theta -> "Theta"
in
List.filter_map (fun lim ->
let v = Float.abs (get_greek lim.greek) in
if v >= lim.max_abs then
Some { greek = name_of lim.greek; value = v; limit = lim.max_abs; is_warning = false }
else if v >= lim.warning then
Some { greek = name_of lim.greek; value = v; limit = lim.warning; is_warning = true }
else None
) limits
let print_breach b =
let level = if b.is_warning then "WARNING" else "BREACH" in
Printf.printf "[%s] %s: %.2f vs limit %.2f\n" level b.greek b.value b.limit
end
19.7 Chapter Summary
Greeks-based risk management is the operational language of any options desk. While Black-Scholes provides formulas for individual option sensitivities, portfolio management requires aggregating these sensitivities across positions and then constructing hedges that neutralise the aggregate exposures to within acceptable tolerances.
The six Greeks each have distinct operational meanings: delta is the equity-equivalent exposure; gamma captures the nonlinearity and is the source of volatility P&L; theta is the daily cost of owning gamma; vega captures sensitivity to implied vol changes; rho captures rate sensitivity; and the second-order sensitivities (vanna, volga) matter for exotic products and vol surface risk.
The gamma-theta identity ($\Theta = -\frac{1}{2}\sigma^2 S^2 \Gamma$) is the most important equation in options trading. It says that long gamma always comes with negative theta — you pay daily time decay as the price for the right to profit from large moves. The fundamental P&L equation of a delta-hedged position over one day is $\frac{1}{2}\Gamma S^2 (\sigma_{\text{realised}}^2 - \sigma_{\text{implied}}^2) dt$: you profit if realised volatility exceeds the implied volatility at which you bought the option, and lose otherwise.
Delta hedging is the first hedge, using the underlying to maintain near-zero delta continuously. Vega hedging is the second, using liquid vanilla options across expiry buckets to manage parallel and non-parallel vol surface moves. Higher-order hedges use additional options to control vanna and volga. Each additional hedge instrument solves one linear equation in the hedged Greeks.
Risk limits on Greeks provide operational discipline, ensuring that desk exposures are commensurate with capital and with the liquidity of available hedging instruments. In a real system, Greek limits are computed and checked in near-real-time as market data updates, with automatic alerts for approaching or breaching thresholds.
Exercises
19.1 [Basic] Simulate a delta-hedged ATM call ($S = K = 100$, $\sigma = 0.20$, $\tau = 0.25$ yr) over a GBM path with daily rebalancing (252 steps). Plot cumulative gamma P&L and theta decay separately. Verify that net P&L matches the prediction $\frac{1}{2}\Gamma S^2(\sigma_r^2 - \sigma_i^2) \Delta t$ on aggregate.
19.2 [Basic] Compute the gamma-theta identity numerically for an ATM call ($S = 100$, $\sigma = 0.20$, $\tau = 0.5$). Verify that the ratio $\Theta / (-\frac{1}{2}\sigma^2 S^2 \Gamma)$ is close to 1.0. How does it change for OTM or deeply ITM options?
19.3 [Intermediate] Build a book of 5 options (different strikes and expiries on the same underlying) and aggregate delta, gamma, and vega. Construct a delta-vega neutral hedge using two liquid options available in the market. Verify that the hedged book has near-zero delta and vega.
19.4 [Intermediate] Implement a vega bucket report: for the book in 19.3, compute total vega at each expiry bucket (1M, 3M, 6M, 1Y). Which expiry bucket dominates? What happens to the book's total vega when a calendar spread is added?
19.5 [Advanced] Implement "gamma scalping": simulate a delta-neutral, long-gamma position over 20 trading days. Compare three scenarios: (a) realised vol = implied vol, (b) realised vol = 1.5× implied vol, (c) realised vol = 0.5× implied vol. Plot the daily P&L attribution (gamma vs theta) for each scenario and verify the P&L formula.