Case study: delta–gamma–vega P&L

The call as a function of two variables

Hold the strike $K$, the rate $r$ and the time to expiry $T$ fixed. Then the call's value $V(S, \sigma)$ is a function of two variables: the stock price $S$ and the volatility $\sigma$, a decimal per year. Case study 4.1.4 took its partial derivatives one at a time. Its gradient is $(\Delta, \text{vega})$: delta $\frac{\partial V}{\partial S} = 0.570158$ and vega $\frac{\partial V}{\partial \sigma} = 27.7721$, or 0.2777 per vol point, for the six-month call at the money.

Its Hessian (lesson 4.3.1) has three different entries:

• Gamma $\Gamma = \frac{\partial^2 V}{\partial S^2}$, the change in delta per dollar (case study 2.7.4).
• Vanna $= \frac{\partial^2 V}{\partial S\,\partial\sigma}$. Mixed partials do not depend on the order (lesson 4.1.2), so it is two things at once: the change in delta per unit of $\sigma$, and the change in vega per dollar.
• Volga $= \frac{\partial^2 V}{\partial \sigma^2}$, the change in vega per unit of $\sigma$.

The Derivatives Modelling course derives the formulas; here, take them as given and check them by bumping. They use $d_1$ and $d_2 = d_1 - \sigma\sqrt{T}$ from case study 2.4.6, and the standard normal density $\varphi$.

At the money, $d_2 = 0.0354$ is close to 0, so vanna and volga are both small. At strike 120, $d_1$ and $d_2$ are both near $-1.2$. Vanna is positive there: a rise in volatility makes the call more likely to finish in the money, so its delta rises. Volga is large: vega itself grows with volatility.

Per vol point. Desks measure volatility moves in vol points, 0.01 of $\sigma$ (case study 2.4.6). For strike 120, vanna $\times\ 0.01 = 0.0135$ is the rise in delta for one vol point; the delta formula at 21% gives 0.1463, up from 0.1330. Volga $\times\ 0.01^2 = 0.0106$ is the rise in vega per vol point, for one vol point; at 21% it rises by 0.0102.

Checking by bumping

Lesson 4.1.2's central differences estimate all three entries from prices alone. With case study 2.8.4's bumps, $1 to the stock ($h = 1$, or 1%) and one vol point to the volatility ($k = 0.01$), it takes nine prices: today's, the stock bumped up and down, the volatility bumped up and down, and the four corners for vanna.

Every bumped value is within about 0.5% of the formula. At the money the relative errors look largest only because vanna and volga are so small there.

The second-order estimate

Write $\Delta S$ for the change in the stock price and $\Delta\sigma$ for the change in volatility, as a decimal. The step is $\mathbf{h} = (\Delta S, \Delta\sigma)$, and lesson 4.3.1's quadratic copy of $V$ gives the change $\Delta V$.

Time is held fixed: this is an instant move, as in a stress test. Case studies 4.1.4 and 4.2.4 add theta for the passage of a day.

The letter $\Delta$ still has two jobs, as in case study 2.7.4: alone it is delta, and in $\Delta S$ it means "change in". Here is the sell-off of the hook, $\Delta S = -8$ and $\Delta\sigma = 0.05$, term by term:

For strike 120, delta, gamma and vega add up to a gain of 0.1821. The vanna term, $-0.5388$, turns it into a loss: the rise in volatility lifted delta, so the fall in the stock cost more than delta alone says. With all five terms the estimate is within 2 cents of repricing.

At the money the two cross terms add only 0.0289, and the estimate stays 17 cents off. The section on failures explains that gap.

A grid of scenarios

A risk system does not look at one scenario. It reprices a grid: here the stock moves by $-10$, $-5$, $-2$, 0, 2, 5 or 10 dollars and the volatility by $-5$, $-2$, 0, 2 or 5 vol points, 35 scenarios in all. Each estimate is scored by its largest error and by its root-mean-square error: square each error, average, and take the square root.

Neither first-order nor stock-only estimates are good enough once both inputs move: their RMS errors are 52 to 87 cents. At the money, gamma and vega do the rest of the work, and vanna and volga change almost nothing. At strike 120 they cut the RMS error almost three times, from 0.2710 to 0.0944.

The pattern holds away from the money on either side:

Where it fails

At the money: the terms of degree 3

Case study 4.1.4's estimate missed its worst night, the stock down $10 and volatility up 5 points, by $-0.2165$. It traced the miss to vega changing with the stock: 26.34 at $95, against 27.77 at $100. Vanna is that change per dollar, but measured at $100 itself.

There vanna is only $-0.0694$: vega peaks at $99.50, so at $100 it is almost flat. Moved by vanna alone, vega would be 28.12 at $95, higher rather than lower. What brings it down to 26.34 is the bend of vega in $S$, about $-0.138$ per dollar squared, and that is a term of degree 3 in the expansion of $V$ (lesson 4.3.1). With the bend, the estimate of vega at $95 is 26.40.

So at the money the second-order estimate still misses the $8 sell-off of the term table by $-0.1682$. Its largest term of degree 3 is $\frac{1}{2}\frac{\partial\Gamma}{\partial\sigma}(\Delta S)^2\Delta\sigma$. Since the order of differentiation does not matter, $\frac{\partial\Gamma}{\partial\sigma}$ is the same bend of vega, $-0.1383$ by a central difference.

That term is $-0.2213$, and the next one, $\frac{1}{6}\frac{\partial\Gamma}{\partial S}(\Delta S)^3$, is $+0.0531$. Together they make $-0.1682$, the whole miss. The second-order estimate cannot see them, however carefully its five Greeks are computed.

Large moves

The error of degree 3 grows like the cube of the move. In a crash, with the stock down $20 and volatility up 10 points, the at-the-money call loses 4.7508. The second-order estimate says 2.9283, off by 1.8225, or 38% of the loss. For strike 120 and a $20 rally with volatility down 5 points, the estimate is off by 1.3657.

Near expiry

Case study 2.7.4 found gamma growing like $\frac{1}{\sqrt{T}}$ at the money, as the price curve closes in on the payoff's corner. The same happens to the whole expansion. On the same 35-scenario grid, for the at-the-money call:

With a week left the typical error is larger than the price of the option. For short-dated options near the money, desks reprice every scenario.

import math

from scipy.stats import norm


def _call(S, K, T, r, sigma):
    d1 = (math.log(S / K) + (r + sigma**2 / 2) * T) / (sigma * math.sqrt(T))
    return S * norm.cdf(d1) - K * math.exp(-r * T) * norm.cdf(d1 - sigma * math.sqrt(T))


def _triple(result):
    assert isinstance(result, tuple) and len(result) == 3, f"expected a tuple (gamma, vanna, volga), got {result!r}"
    return result


def test_at_the_money():
    """The 6-month call at strike 100: gamma 0.027772, vanna −0.069430, volga 0.867879"""
    gamma, vanna, volga = _triple(call_second_order(100, 100, 0.5, 0.03, 0.2))
    expect_close(gamma, 0.027772131739916564, what="gamma", rel=1e-9)
    expect_close(vanna, -0.06943032934979133, what="vanna", rel=1e-9)
    expect_close(volga, 0.8678791168723916, what="volga", rel=1e-9)


def test_out_of_the_money():
    """Strike 120: vanna 1.347119 and volga 105.9655, far from zero"""
    _, vanna, volga = _triple(call_second_order(100, 120, 0.5, 0.03, 0.2))
    expect_close(vanna, 1.3471194695733808, what="vanna at strike 120", rel=1e-9)
    expect_close(volga, 105.9654660703653, what="volga at strike 120", rel=1e-9)


def test_by_bumping():
    """Vanna and volga match central differences of the price for S = 50, K = 55, T = 0.25, σ = 0.35"""
    S, K, T, r, s, h, k = 50, 55, 0.25, 0.01, 0.35, 1e-2, 1e-3
    vanna_b = (_call(S + h, K, T, r, s + k) - _call(S + h, K, T, r, s - k) - _call(S - h, K, T, r, s + k) + _call(S - h, K, T, r, s - k)) / (4 * h * k)
    volga_b = (_call(S, K, T, r, s + k) - 2 * _call(S, K, T, r, s) + _call(S, K, T, r, s - k)) / k**2
    _, vanna, volga = _triple(call_second_order(S, K, T, r, s))
    expect_close(vanna, vanna_b, what="vanna against the four-corner difference", rel=1e-4)
    expect_close(volga, volga_b, what="volga against the second difference in sigma", rel=1e-4)


def test_sell_off():
    """Strike 120, stock −$8 and volatility +5 points: −0.2243, within 3 cents of repricing (−0.2438)"""
    est = second_order_change(100, 120, 0.5, 0.03, 0.2, -8, 0.05)
    expect_close(est, -0.22428677057242452, what="second_order_change(..., dS=-8, dsigma=0.05)", rel=1e-8)
    true = _call(92, 120, 0.5, 0.03, 0.25) - _call(100, 120, 0.5, 0.03, 0.2)
    assert abs(est - true) < 0.03, f"expected within 0.03 of the repriced change {true:.4f}, got {est:.4f}"


def test_stock_only():
    """With no volatility move it is case study 2.7.4's delta–gamma estimate: −2.5036 for a $5 fall"""
    expect_close(second_order_change(100, 100, 0.5, 0.03, 0.2, -5, 0), -2.503638865254377, what="second_order_change(..., dS=-5, dsigma=0)", rel=1e-8)


def test_volatility_only():
    """With no stock move it is vega·Δσ + ½·volga·Δσ²: 1.3897 for +5 vol points"""
    expect_close(second_order_change(100, 100, 0.5, 0.03, 0.2, 0, 0.05), 1.3896914358919188, what="second_order_change(..., dS=0, dsigma=0.05)", rel=1e-8)


def test_at_expiry():
    """T = 0 raises ValueError: the formulas divide by zero"""
    try:
        call_second_order(100, 100, 0, 0.03, 0.2)
    except ValueError:
        return
    raise AssertionError("expected ValueError for T = 0")


def test_zero_volatility():
    """σ = 0 raises ValueError in second_order_change too"""
    try:
        second_order_change(100, 100, 0.5, 0.03, 0, 1, 0.01)
    except ValueError:
        return
    raise AssertionError("expected ValueError for sigma = 0")