Case study: duration–convexity and delta–gamma

The bond estimate is a Taylor polynomial

Case study 2.4.5 estimated the price change of the 5-year 4% bond at a 5% yield with duration $D$ and convexity $C$. Here $y$ is the yield and $\Delta y$ its change, both decimals. Write the quadratic copy of the price $P(y)$ in step form (lesson 2.7.1), with step $\Delta y$:

Subtract $P(y)$ and divide by it. Since $D = -\frac{P'}{P}$ (case study 2.2.4) and $C = \frac{P''}{P}$ (case study 2.4.5), the right side becomes case study 2.4.5's estimate.

Case study 2.4.5's numbers follow. At 5%, $P = 95.6705$, $P' = -420.9797$ and $P'' = 2341.2878$. For a 2% rise the copy gives $95.6705 - 8.4196 + 0.4683 = 87.7192$: in percent, $-8.8006\% + 0.4894\%$, as there.

The third-order term

The next term of the copy is $\frac{P'''(y)}{3!}(\Delta y)^3$. Differentiating one payment $c_t(1 + y)^{-t}$ a third time, by the power and chain rules (lessons 2.3.1 and 2.3.3), gives $-t(t + 1)(t + 2)\,c_t(1 + y)^{-t-3}$.

That is negative for every payment, so $P''' < 0$ for any bond with positive payments. Here $P''' = -15397.35$, so the cubic term is $-0.0205$ for a 2% rise and $+0.0205$ for a 2% fall.

Case study 2.4.5 saw the duration–convexity error grow about eight times when the move doubled, and change sign. Lesson 2.7.1 explains both: a quadratic copy misses by about a constant times $(\Delta y)^3$, an odd power. The cubic term is most of that miss; each error below is the true price minus the estimate.

With the cubic term the error falls about 25 times at $\pm 2\%$. Because $P''' < 0$, for moves like these the quadratic copy overshoots when yields rise and undershoots when they fall.

When it matters

For the 5-year bond the cubic term is about 2 cents on a 2% move. It grows fast with maturity, like convexity in case study 2.4.5. For a 2% rise, per $100 of face value:

For the 30-year zero, the duration–convexity estimate is off by about 3% of the price. A stress test with moves this large on long bonds needs the third term, or simply a full repricing, which is cheap for a bond.

Even the cubic term leaves 0.15 on the 30-year coupon bond: the fourth and later terms still count. Each payment's series in $\Delta y$ converges for $|\Delta y| < 1.05$, the distance from 5% to the break at $y = -1$ (lesson 2.7.2), so more terms do close the gap.

Delta and gamma

Now the call of case studies 2.4.6 and 2.6.5: strike $K = 100$, $T = 0.5$ years, rate $r = 0.03$ and volatility $\sigma = 0.2$, with the stock at $S_0 = 100$. Hold everything but the stock price $S$ fixed, and the price $c(S)$ is a function of one variable.

Its first two derivatives have names. Delta is the slope $\frac{dc}{dS}$, and gamma is the second derivative $\frac{d^2c}{dS^2}$. The Derivatives Modelling course derives both formulas; here, take them as given.

At $S_0 = 100$, $d_1 = 0.176777$, $N(d_1) = 0.570158$ and $\varphi(d_1) = 0.392757$. So $\Delta = 0.5702$: the option gains about 57 cents per $1 rise in the stock. And $\Gamma = \frac{0.392757}{100 \times 0.2 \times \sqrt{0.5}} = 0.0278$: each $1 rise adds about 0.0278 to delta.

For a call, $N(d_1)$ lies between 0 and 1. Gamma is positive, so $c(S)$ is concave up (lesson 2.4.2), as a bond price is in $y$.

The letter $\Delta$ has two jobs on a desk: alone it is delta, and in $\Delta S$ it means "change in $S$". So $\Delta \cdot \Delta S$ reads "delta times the change in the stock price".

Checking the formulas

A central difference (lesson 2.2.2) with a 1-cent bump, $h = 0.01$, confirms delta: $\frac{c(100.01) - c(99.99)}{0.02} = 0.570158$. The central difference of the delta formula gives 0.027772, and so does the second central difference of the price (lesson 2.4.2).

How to choose the bump is the subject of case study 2.8.4, which computes Greeks by repricing alone.

The delta–gamma estimate

The quadratic copy of $c(S)$ about $S_0$, in step form with step $\Delta S$, is the option version of duration–convexity. Write $\Delta V$ for the change in the option's value.

Each error is the repriced change minus the estimate. Delta alone always comes out too low, because the curve bends above its tangent.

The gamma term fixes most of that. What remains grows about like the cube of the move (lesson 2.7.1): 0.0009 for a $2 rise, 0.0158 for $5 and 0.1422 for $10.

Where it fails

A quadratic copy works when the step is small next to the scale on which the curve bends. For an option, that scale is about $S\sigma\sqrt{T}$, the stock's typical move over the option's remaining life: $14.14 for six months. A $5 move is about a third of that.

Large moves. A $20 move is more than one typical move: the error reaches $-1.27$ on the way up.

Short expiry at the money. As $T$ shrinks, the price curve closes in on the payoff $\max(S - K, 0)$, with its corner at the strike (lesson 2.2.2). At the money, gamma grows like $\frac{1}{\sqrt{T}}$, and the parabola cannot follow a corner.

With a day left the call is worth $0.42 and $\Gamma = 0.3811$. The estimate says a $5 fall makes the call $2.24 more valuable; in fact it loses its whole value, $0.42.

Away from the strike the short-dated curve is almost straight, and the bend crowds around the strike. A week from expiry, gamma is 0.00009 at strike 90 and 0.00044 at strike 110. For short-dated options near the money, desks reprice rather than trust the estimate.

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 _pair(result):
    assert isinstance(result, tuple) and len(result) == 2, f"expected a pair (delta, gamma), got {result!r}"
    return result


def test_six_month_call():
    """The 6-month at-the-money call has delta 0.570158 and gamma 0.027772"""
    delta, gamma = _pair(call_delta_gamma(100, 100, 0.5, 0.03, 0.2))
    expect_close(delta, 0.5701581024006669, what="delta", rel=1e-9)
    expect_close(gamma, 0.027772131739916564, what="gamma", rel=1e-9)


def test_delta_by_central_difference():
    """Delta matches a central difference of the price for S = 50, K = 55, T = 0.25, σ = 0.35"""
    h = 1e-4
    bumped = (_call(50 + h, 55, 0.25, 0.01, 0.35) - _call(50 - h, 55, 0.25, 0.01, 0.35)) / (2 * h)
    delta, _ = _pair(call_delta_gamma(50, 55, 0.25, 0.01, 0.35))
    expect_close(delta, bumped, what="delta against the central difference", rel=1e-6)


def test_gamma_by_second_difference():
    """Gamma matches the second central difference of the price for the same option"""
    h = 1e-3
    bumped = (_call(50 + h, 55, 0.25, 0.01, 0.35) - 2 * _call(50, 55, 0.25, 0.01, 0.35) + _call(50 - h, 55, 0.25, 0.01, 0.35)) / h**2
    _, gamma = _pair(call_delta_gamma(50, 55, 0.25, 0.01, 0.35))
    expect_close(gamma, bumped, what="gamma against the second central difference", rel=1e-4)


def test_five_dollar_fall():
    """A $5 fall: the estimate is −2.5036, within a cent of repricing (−2.4940)"""
    est = delta_gamma_change(100, 100, 0.5, 0.03, 0.2, -5)
    expect_close(est, -2.503638865254377, what="delta_gamma_change(..., dS=-5)", rel=1e-8)
    true = _call(95, 100, 0.5, 0.03, 0.2) - _call(100, 100, 0.5, 0.03, 0.2)
    assert abs(est - true) < 0.01, f"expected within 0.01 of the repriced change {true:.4f}, got {est:.4f}"


def test_both_directions():
    """The gamma term is added both ways: +$5 gives 3.1979, more than delta alone (2.8508)"""
    expect_close(delta_gamma_change(100, 100, 0.5, 0.03, 0.2, 5), 3.1979421587522916, what="delta_gamma_change(..., dS=5)", rel=1e-8)


def test_in_the_money():
    """In the money (strike 90), delta is 0.8217 and gamma 0.0184"""
    delta, gamma = _pair(call_delta_gamma(100, 90, 0.5, 0.03, 0.2))
    expect_close(delta, 0.8216804280613134, what="delta at strike 90", rel=1e-9)
    expect_close(gamma, 0.01844533441808336, what="gamma at strike 90", rel=1e-9)


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


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