Case study: bump-and-reprice Greeks

Greeks by repricing

The sensitivities of an option's value to its inputs are its Greeks. Each is a derivative with respect to one input, all the others held fixed. Take the call of case studies 2.4.6 and 2.6.5: stock price $S = 100$, strike $K = 100$, $T = 0.5$ years, rate $r = 0.03$ and volatility $\sigma = 0.2$, worth $6.3710.

• Delta $\Delta$ is the slope of the price $c$ in $S$. Case study 2.7.4 gave it as $N(d_1) = 0.570158$, in dollars of option per dollar of stock.
• Gamma $\Gamma$ is the second derivative in $S$, $\frac{\varphi(d_1)}{S\sigma\sqrt{T}} = 0.027772$ (case study 2.7.4): the change in delta per dollar.
• Vega is the slope in $\sigma$, $S\sqrt{T}\,\varphi(d_1) = 27.7721$ (case study 2.4.6). Desks quote it per vol point, a change of 0.01 in $\sigma$: 0.2777.

Here $N$ is the standard normal cumulative distribution, $\varphi$ its density, and $d_1$ the one in case study 2.4.6's formula. A pricing system replaces each derivative by a finite difference of the price, as in lesson 2.8.1.

Case study 2.7.4 checked delta and gamma with a 1-cent bump. Desks usually bump the stock by 1% and the volatility by one vol point, $k = 0.01$:

These are truncation errors (lesson 2.8.1), 0.02% of delta and 0.04% of gamma. That is far below the doubt in the inputs themselves: nobody knows the volatility to four digits.

How big a bump?

Lesson 2.8.1 split the error of a difference into two parts. Truncation grows with the bump; rounding grows as the bump shrinks, and for a second difference it grows like $\frac{1}{h^2}$. Here is the call with bumps from 10% of the stock price down to $10^{-9}$ of it:

Gamma is the sensitive one. Its best bump is near 1 cent, which is lesson 2.8.1's $\varepsilon^{1/4}s$ with the scale $s = S = 100$: 0.012. Delta's best bump, near $\varepsilon^{1/3}s \approx 6 \times 10^{-4}$, is smaller. Rounding barely touches delta: even with a bump of $10^{-7}$ dollars it is off by only $3.1 \times 10^{-8}$.

So why do desks bump by 1%, a hundred times the best step for this formula? First, a 1% move is one the market really makes, so the bumped numbers describe a plausible day. Case study 2.2.4 said the same of the 1 bp bump.

Second, most pricers are far noisier than this formula.

A noisy pricer

Case study 2.6.5 also priced this call with quad over the whole line, corner and all, and got 6.37102797: about $3 \times 10^{-8}$ above the formula. That error changes a little whenever $S$ moves. In lesson 2.8.1's rounding ceiling, $\frac{2\varepsilon|c|}{h^2}$, it takes the place of $\varepsilon|c| \approx 10^{-15}$.

The bumped gammas from that pricer show the effect. A 1% bump gives 0.027762 and a 10-cent bump 0.027766, both fine. A 1-cent bump gives 0.027315, 1.6% low, and a bump of a tenth of a cent gives $-0.031782$.

The noisier the pricer, the larger the best bump. Trees and simulations, met in later courses, are noisier still. So desks keep bumps near 1% and check that halving the bump barely changes the answer.

Where bumping misbehaves

Close to expiry

Case study 2.7.4 found that close to expiry the price curve nears the payoff's corner at the strike. The bend crowds into a range of about $S\sigma\sqrt{T}$: $14.14 for six months, $1.05 for a day. A 1% bump is $1, so a day out it is as wide as the bend.

A bump must be small next to the scale on which the price bends, which here is $S\sigma\sqrt{T}$, not $S$. With a day left, a 10-cent bump gives 0.3808. The figure shows the 1% bump flattening the whole peak of gamma, not just its top.

At expiry: a corner and a jump

At expiry the call is worth its payoff, $\max(S - K, 0)$, with a corner at the strike. The gamma formula divides by $\sqrt{T} = 0$ there. The bump still returns a number: $\frac{h - 2 \cdot 0 + 0}{h^2} = \frac{1}{h}$, whatever $h$ is.

A digital call pays $1 if the stock ends above the strike and nothing otherwise. At expiry its value jumps at the strike, and its bumped delta there is $\frac{1}{2h}$.

The bumped number measures the bump, not the option: this is lesson 2.8.1's corner inside the step. Desks therefore treat such payoffs with care, for instance booking a digital as a narrow call spread, which has a slope rather than a jump.

A numerical present value

Case study 2.5.5 valued $10,000 a year of tolls for 10 years at a continuous 5%: $78,693.87 exactly. Its payment schedules are lesson 2.8.2's rules. Payments at year-starts and year-ends are the left and right sums, so their average, $78,710.26, is the trapezoid rule; mid-year payments, $78,685.67, are the midpoint sum.

Combined as $\frac{2M + T}{3}$, they give Simpson's rule with 20 half-year strips: $78,693.87, right to the cent. Simpson's rule needs only 2 strips, values at years 0, 5 and 10, to come within $1.70. With 4 strips it is 11 cents off.

The same few lines value a stream whose discounted rate has no antiderivative, where no closed form exists to check against.

import math

from scipy.stats import norm


def _call(S, sigma, K=100.0, T=0.5, r=0.03):
    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 _formulas(S, sigma, K=100.0, T=0.5, r=0.03):
    d1 = (math.log(S / K) + (r + sigma**2 / 2) * T) / (sigma * math.sqrt(T))
    return norm.cdf(d1), norm.pdf(d1) / (S * sigma * math.sqrt(T)), S * math.sqrt(T) * norm.pdf(d1) / 100


def test_six_month_call():
    """The six-month call with 1% and one-vol-point bumps: delta 0.570054, gamma 0.027762, vega 0.277717"""
    delta, gamma, vega = bump_greeks(_call, 100.0, 0.2)
    expect_close(delta, 0.570054062469417, what="delta", rel=1e-9)
    expect_close(gamma, 0.027762255136636327, what="gamma", rel=1e-9)
    expect_close(vega, 0.27771682820363, what="vega per vol point", rel=1e-9)


def test_close_to_formulas():
    """The bumped Greeks agree with the closed forms to within 0.1%"""
    for got, exact, name in zip(bump_greeks(_call, 100.0, 0.2), _formulas(100.0, 0.2), ("delta", "gamma", "vega")):
        expect_close(got, exact, what=name, rel=1e-3)


def test_by_hand():
    """For price S²σ at S = 3, σ = 0.5: delta 3, gamma 1 and vega 0.09 per vol point"""
    delta, gamma, vega = bump_greeks(lambda S, sigma: S**2 * sigma, 3.0, 0.5)
    expect_close(delta, 3.0, what="delta of S²σ", rel=1e-9)
    expect_close(gamma, 1.0, what="gamma of S²σ", rel=1e-6)
    expect_close(vega, 0.09, what="vega of S²σ per vol point", rel=1e-9)


def test_relative_bump():
    """The stock bump is relative: a $5 stock with strike $5 has gamma within 0.1% of 0.555443"""
    price = lambda S, sigma: _call(S, sigma, K=5.0)
    gamma = bump_greeks(price, 5.0, 0.2)[1]
    expect_close(gamma, _formulas(5.0, 0.2, K=5.0)[1], what="gamma of the $5 option", rel=1e-3)


def test_smaller_bump():
    """A smaller relative bump, 0.0001, gives gamma within 10⁻⁸ of the formula"""
    gamma = bump_greeks(_call, 100.0, 0.2, rel_bump=1e-4)[1]
    expect_close(gamma, _formulas(100.0, 0.2)[1], what="gamma with rel_bump=1e-4", abs_tol=1e-8, rel=0)


def test_bad_stock_price():
    """A stock price of 0 raises ValueError"""
    try:
        bump_greeks(_call, 0.0, 0.2)
    except ValueError:
        return
    raise AssertionError("expected ValueError for S = 0")


def test_vol_bump_too_big():
    """A volatility bump of 0.25 when σ = 0.2 raises ValueError"""
    try:
        bump_greeks(_call, 100.0, 0.2, vol_bump=0.25)
    except ValueError:
        return
    raise AssertionError("expected ValueError: σ − 0.25 is negative")