Case study: the Greeks as partial derivatives

One value, several inputs

Take the call of case studies 2.4.6, 2.7.4 and 2.8.4: strike $K = 100$, expiry $T = 0.5$ years from today, interest rate $r = 0.03$. Today the stock price is $S = 100$ and the volatility $\sigma = 0.2$, and the call is worth $6.3710.

The strike and the expiry date are fixed by the contract. The stock price, the volatility and the date move.

Measure the date $t$ in years from today, so $T - t$ is the time left. Then the value is a function of three variables, $V(S, \sigma, t)$:

This is case study 2.4.6's formula with $T - t$ in place of $T$. $N$ is the standard normal distribution function and $\varphi$, below, its density (lesson 2.6.3). The rate $r$ can move too, so it is a fourth input.

A Greek is the sensitivity of the value to one input with the others held fixed. That is exactly a partial derivative, so each Greek is the slope of one slice of $V$ (lesson 4.1.1).

Delta and gamma came from case study 2.7.4, and vega from case study 2.4.6. Theta and rho are new:

The signs say how a long call responds. It gains when the stock rises ($\Delta > 0$), when volatility rises (vega $> 0$) and when rates rise (rho $> 0$). It loses value as time passes ($\Theta < 0$).

Slices and level curves of the value

Hold $t$ and $r$ fixed, and $V$ is a function of two variables, $S$ and $\sigma$. It has a surface and a contour map, like the functions of lesson 4.1.1.

Slices. Fix $\sigma$ and let $S$ move: that is case study 2.7.4's curve, and delta is its slope. At $S = 100$ the slices for 10%, 20% and 30% volatility give 3.6065, 6.3710 and 9.1494. The steps of 10 vol points add 2.7645 and 2.7784, close to vega's $27.7721 \times 0.1 = 2.7772$.

Level curves. The value rises with $S$ and with $\sigma$. So along a level curve, a lower stock price must come with a higher volatility. The curve through today's point passes $(95, 29.38\%)$ and $(90, 37.97\%)$.

Each point on that curve is an implied volatility, as in case study 2.4.6. If the stock were at $95 and the call still traded at $6.37, the market would be pricing 29.38% volatility.

To the right the curve ends. It meets $\sigma = 0$ at $S = 6.3710 + 100e^{-0.015} = 104.88$.

Case study 2.4.6 showed that the value never falls below $S - Ke^{-rT}$, its value with no uncertainty. With the stock at $105 that floor is 6.4888, so no volatility gives $6.37.

Theta: the passage of time

Hold $S$ and $\sigma$ fixed and let the date move on. The time left $T - t$ shrinks, and the value changes at the rate $\Theta = \frac{\partial V}{\partial t}$. For a call it has two parts:

The first part comes from volatility: less time left means less chance of the large move the option pays for. The second is about the strike, paid at expiry. As expiry comes closer, its present value $Ke^{-r(T - t)}$ grows, and that lowers the call's value.

With $r \ge 0$ both parts are negative, so a call's theta is negative. The first part is also $-\frac{1}{2}\sigma^2S^2\Gamma$, since $\frac{S\varphi(d_1)\sigma}{2\sqrt{T - t}} = \frac{1}{2}\sigma^2S^2 \cdot \frac{\varphi(d_1)}{S\sigma\sqrt{T - t}}$. An option with a lot of gamma pays for it with a lot of theta.

Per day

$-7.0738$ is per year, an awkward unit for something that happens daily. Desks divide by 365 for a calendar day, $-0.0194$, or by 252 for a trading day, $-0.0281$. So with nothing else moving, the call loses about 2 cents a day.

Repricing agrees. Moving the date one day forward changes the value by $-0.019402$, against $\Theta \div 365 = -0.019380$. The small gap is the forward difference's error (lesson 2.8.1): theta itself changes over the day.

Close to expiry

At the money, theta grows as expiry nears, like gamma in case study 2.7.4. Here it is per day, with $S$ and $\sigma$ fixed:

With a day left the call loses half its value overnight, if nothing moves. At $T - t = 0$ the formula divides by zero: at expiry the value is the payoff, with its corner at the strike.

The slope in the time to expiry $T$ is $+7.0738$: the same number with the opposite sign. More time to expiry is worth more, and time passing takes it away. Check which of the two a system reports before adding it to anything.

Rho, and all five by bumping

Rho is the slope in $r$, with $S$, $\sigma$ and $t$ fixed: $K(T - t)e^{-r(T - t)}N(d_2) = 25.3224$. Desks quote it per percentage point of rate, 0.2532: each point of rate is worth about 25 cents.

It is positive because a higher rate makes the strike, paid later, cheaper today. For a six-month option it is small; it grows with the time left.

Case study 2.8.4 checked delta, gamma and vega by bump-and-reprice: move one input a little, reprice and divide. The same works for theta and rho. Each bump moves one input and holds the others fixed, so it is a finite difference of a slice (lesson 4.1.2).

The first three rows are case study 2.8.4's. All five agree to about 0.1% or better; theta's one-sided bump is the least accurate, as lesson 2.8.1 predicts.

Overnight: adding vega and theta

Case study 2.7.4's estimate moved only $S$. When $\sigma$ and $t$ move too, add one term for each, using its own partial derivative:

Each error below is the repriced change minus the estimate, as in case study 2.7.4.

The hook's night is the third row. Delta–gamma alone misses by 26 cents; with vega and theta the estimate is within a tenth of a cent.

A sell-off usually comes with rising volatility, as in the last two rows. There, ignoring vega would miss by 83 cents and $1.39.

What is left grows when both moves are large. It comes from vega changing with $S$: with the stock at $95, vega is 26.34, not 27.77, so three vol points are worth about 4 cents less than the estimate assumes. Case study 4.3.4 finds that at the money most of this change is of degree 3 in the moves.

Lesson 4.2.2 explains why the separate terms can simply be added: the total differential. Case study 4.2.4 uses it to split a day's profit and loss among the inputs, and case study 4.3.4 adds the mixed second-order terms.

import math

from scipy.stats import norm


def _value(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 test_delta_gamma():
    """The six-month call has delta 0.570158 and gamma 0.027772"""
    g = call_greeks(100, 100, 0.5, 0.03, 0.2)
    expect_close(g["value"], 6.3710279, what="value", rel=1e-6)
    expect_close(g["delta"], 0.5701581, what="delta", rel=1e-6)
    expect_close(g["gamma"], 0.0277721, what="gamma", rel=1e-5)


def test_vega_per_vol_point():
    """Vega is quoted per vol point: 0.2777 for the six-month call"""
    expect_close(call_greeks(100, 100, 0.5, 0.03, 0.2)["vega"], 0.2777213, what="vega per vol point", rel=1e-5)


def test_theta_per_day():
    """Theta is per calendar day and negative: -0.0194 for the six-month call"""
    expect_close(call_greeks(100, 100, 0.5, 0.03, 0.2)["theta"], -7.0737698 / 365, what="theta per day", rel=1e-5)


def test_rho_per_point():
    """Rho is per percentage point of rate: 0.2532 for the six-month call"""
    expect_close(call_greeks(100, 100, 0.5, 0.03, 0.2)["rho"], 0.2532239, what="rho per point", rel=1e-5)


def test_matches_bumps():
    """Every Greek matches bump-and-reprice for a one-year call at strike 110"""
    S, K, T, r, s = 95, 110, 1.0, 0.04, 0.3
    g = call_greeks(S, K, T, r, s)
    h, k = 0.01, 1e-4
    expect_close(g["delta"], (_value(S + h, K, T, r, s) - _value(S - h, K, T, r, s)) / (2 * h), what="delta", rel=1e-6)
    expect_close(g["gamma"], (_value(S + h, K, T, r, s) - 2 * _value(S, K, T, r, s) + _value(S - h, K, T, r, s)) / h**2,
                 what="gamma", rel=1e-4)
    expect_close(g["vega"], (_value(S, K, T, r, s + k) - _value(S, K, T, r, s - k)) / (2 * k) / 100, what="vega per vol point", rel=1e-6)
    expect_close(g["theta"], -(_value(S, K, T + k, r, s) - _value(S, K, T - k, r, s)) / (2 * k) / 365, what="theta per day", rel=1e-6)
    expect_close(g["rho"], (_value(S, K, T, r + k, s) - _value(S, K, T, r - k, s)) / (2 * k) / 100, what="rho per point", rel=1e-6)


def test_hook_night():
    """The stock falls $2, volatility rises one point, a day passes: the estimate is -0.8264"""
    expect_close(overnight_change(100, 100, 0.5, 0.03, 0.2, -2, 0.01, days=1), -0.8264308, what="overnight_change", rel=1e-5)


def test_weekend():
    """With nothing moving, a weekend costs three days of theta"""
    expect_close(overnight_change(100, 100, 0.5, 0.03, 0.2, 0, 0, days=3), -0.0581406, what="overnight_change over 3 days", rel=1e-5)


def test_bad_inputs():
    """T = 0 and sigma = 0 raise ValueError: the formulas divide by zero"""
    for args in [(100, 100, 0.0, 0.03, 0.2), (100, 100, 0.5, 0.03, 0.0)]:
        try:
            call_greeks(*args)
        except ValueError:
            continue
        raise AssertionError(f"expected ValueError for call_greeks{args}")


def test_days_past_expiry():
    """A move of 200 days on a six-month call raises ValueError"""
    try:
        overnight_change(100, 100, 0.5, 0.03, 0.2, 0, 0, days=200)
    except ValueError:
        return
    raise AssertionError("expected ValueError: 200 days is past expiry")