6.3.4 Case study: an option value fixed by its payoff

The Black–Scholes equation

Take the call of case studies 2.4.6 and 4.1.4: strike $K = 100$ , expiry $T = 0.5$ years, rate $r = 0.03$ and volatility $\sigma = 0.2$ , both yearly decimals. Its value $V(S, t)$ depends on the stock price $S$ and the date $t$ , in years from today, so $T - t$ is the time left.

Rule: The Black–Scholes equation

V_t + \tfrac{1}{2}\sigma^2S^2\,V_{SS} + rS\,V_S - rV = 0

For every stock price $S > 0$ and every date $t < T$ . $V_t$ , $V_S$ and $V_{SS}$ are partial derivatives (lesson 4.1.2). The Stochastic Calculus course derives the equation from a hedging argument; here, take it as given, as case study 2.4.6 took the formula.

Read it with lesson 6.3.1. It is linear: $V$ and its partials appear only on their own, multiplied by $\frac{1}{2}\sigma^2S^2$ , $rS$ or $-r$ . Its order is 2, from $V_{SS}$ .

Unlike the heat equation, its coefficients depend on $S$ . Case study 6.4.4 changes variables to turn it into the heat equation itself.

Which way it runs

Move the other terms across: $V_t = -\frac{1}{2}\sigma^2S^2V_{SS} - rSV_S + rV$ . The coefficient of $V_{SS}$ is negative, as in lesson 6.3.2's $u_t = -k\,u_{xx}$ . So the equation runs backwards in time, and needs a terminal condition, at expiry.

In the time left $\tau = T - t$ , $V_t = -V_\tau$ , and the equation runs forwards in $\tau$ from the payoff. That is why every formula of case study 4.1.4 contains $T - t$ .

If an option never expires, nothing depends on $t$ , so $V_t = 0$ . The equation becomes the ODE $\frac{1}{2}\sigma^2S^2V'' + rSV' - rV = 0$ , which case study 6.2.4 solves for the perpetual American put.

Conditions: the payoff and the two ends

The region is $S > 0$ and $t \le T$ : a strip in the $(S, t)$ plane, open on the side of large $S$ . Its conditions, edge by edge:

At expiry, $t = T$ . The call is worth its payoff: $V(S, T) = \max(S - K, 0)$ .
At $S = 0$ . In this model a stock that reaches 0 stays there. Put $S = 0$ in the equation: the two terms with $S$ vanish, leaving the ODE $V_t = rV$ of module 6.1. So $V(0, t) = V(0, T)\,e^{-r(T - t)}$ , and for the call $V(0, T) = 0$ : the call is worthless.
For large $S$ . Exercise is all but certain, so the call is worth the stock minus the strike paid at expiry: $V \approx S - Ke^{-r(T - t)}$ . That is case study 2.4.6's floor.

Rule: The call's conditions

\begin{gathered} V(S, T) = \max(S - K, 0) \\[4pt] V(0, t) = 0 \\[4pt] V \approx S - Ke^{-r(T - t)} \text{ for large } S \end{gathered}

A terminal condition on the edge $t = T$ and a condition at each end of the $S$ range. With them the problem is well-posed (lesson 6.3.2), and the Black–Scholes formula is its solution.

The formula meets each condition. Today, at $S = 150$ it gives 51.4960 against the floor's 51.4888, and at $S = 200$ the gap is only $1.0 \times 10^{-6}$ . At $S = 20$ the call is worth less than $10^{-20}$ .

The call's value as a surface over $(S, t)$ and as slices. The equation carries the payoff, on the back edge, back to today's smooth curve, which nears the payoff's corner as expiry approaches.

S = 150

⌘/Ctrl + Enter runs the cell

Checking the formula by finite differences

Lesson 6.3.1 tested a candidate by computing its partials and substituting. Here, reprice the call at bumped points and estimate $V_t$ , $V_S$ and $V_{SS}$ by central differences (lesson 4.1.2). The residual is then the left side of the equation.

With desk bumps, 1% of $S$ and one day each way in $t$ :

$(S, t)$	$V_t$	$V_S$	$V_{SS}$	residual	with bumps 10 times smaller
$(80, 0)$	$-1.8731$	0.080751	0.013216	0.0007	$6.8 \times 10^{-6}$
$(100, 0)$	$-7.0738$	0.570054	0.027762	$-0.0023$	$-2.3 \times 10^{-5}$
$(120, 0)$	$-4.9932$	0.928491	0.008033	0.0011	$1.1 \times 10^{-5}$
$(100, 0.25)$	$-9.4354$	0.549590	0.039553	$-0.0067$	$-6.7 \times 10^{-5}$
$(100, 0.45)$	$-19.3312$	0.521960	0.088703	$-0.0805$	$-8.1 \times 10^{-4}$

Every residual is small next to the terms, which run to 19. Bumps 10 times smaller make it 100 times smaller: truncation error of size $h^2$ (lesson 2.8.1), the mark of a true solution. The formula solves the equation.

S

import math from scipy.stats import norm def call(S, t=0.0, K=100, T=0.5, r=0.03, sigma=0.2): tau = T - t d1 = (math.log(S / K) + (r + sigma**2 / 2) * tau) / (sigma * math.sqrt(tau)) return S * norm.cdf(d1) - K * math.exp(-r * tau) * norm.cdf(d1 - sigma * math.sqrt(tau)) def residual(price, S, t, hS, ht, r=0.03, sigma=0.2): V_t = (price(S, t + ht) - price(S, t - ht)) / (2 * ht) V_S = (price(S + hS, t) - price(S - hS, t)) / (2 * hS) V_SS = (price(S + hS, t) - 2 * price(S, t) + price(S - hS, t)) / hS**2 return V_t, V_S, V_SS, V_t + 0.5 * sigma**2 * S**2 * V_SS + r * S * V_S - r * price(S, t) day = 1 / 365 for S, t in [(80, 0), (100, 0), (120, 0), (100, 0.25), (100, 0.45)]: V_t, V_S, V_SS, res = residual(call, S, t, 0.01 * S, day) small = residual(call, S, t, 0.001 * S, day / 10)[3] print(S, t, round(V_t, 4), round(V_S, 6), round(V_SS, 6), round(res, 4), f"{small:.1e}")

⌘/Ctrl + Enter runs the cell

A candidate that meets the payoff but fails

Matching the terminal condition is not enough. Take the discounted payoff, $e^{-r(T - t)}\max(S - K, 0)$ : at $t = T$ it is exactly the payoff. Below the strike it is 0, which solves the equation.

Above the strike it is $e^{-r(T - t)}(S - K)$ , with $V_t = r\,e^{-r(T - t)}(S - K)$ , $V_S = e^{-r(T - t)}$ and $V_{SS} = 0$ . The residual is $rS\,e^{-r(T - t)}$ : 3.5464 at $S = 120$ today, and the finite differences agree. The equation is what fixes the value before expiry.

Close to expiry

With one day left, at $S = 100$ , the call is worth 0.4217 and $\Theta = -77.7143$ a year. A $1 bump now gives a gamma of 0.3545 instead of 0.3811, as case study 2.8.4 found, and a residual of $-5.3078$ .

That residual measures the bump, not the formula. The bend crowds into about $S\sigma\sqrt{T - t} = 1.05$ dollars (case study 2.8.4), so a $1 bump is far too wide. With a 10-cent bump the residual is $-0.0588$ , and with 1 cent $-0.0015$ , with the time bump a hundredth of a day.

Theta changes fast too, so the time bump must shrink as well: with a tenth of a day, even the 1-cent bump leaves $-0.0963$ . And a central step of one day, from one day before expiry, reaches $T - t = 0$ , where the formula divides by zero.

rSe^{-r(T - t)}

import math from scipy.stats import norm def call(S, t=0.0, K=100, T=0.5, r=0.03, sigma=0.2): tau = T - t d1 = (math.log(S / K) + (r + sigma**2 / 2) * tau) / (sigma * math.sqrt(tau)) return S * norm.cdf(d1) - K * math.exp(-r * tau) * norm.cdf(d1 - sigma * math.sqrt(tau)) def discounted_payoff(S, t, K=100, T=0.5, r=0.03): return math.exp(-r * (T - t)) * max(S - K, 0) def residual(price, S, t, hS, ht, r=0.03, sigma=0.2): V_t = (price(S, t + ht) - price(S, t - ht)) / (2 * ht) V_S = (price(S + hS, t) - price(S - hS, t)) / (2 * hS) V_SS = (price(S + hS, t) - 2 * price(S, t) + price(S - hS, t)) / hS**2 return V_SS, V_t + 0.5 * sigma**2 * S**2 * V_SS + r * S * V_S - r * price(S, t) day = 1 / 365 for S in [80, 120]: print(S, round(residual(discounted_payoff, S, 0, 0.01 * S, day)[1], 4), round(0.03 * S * math.exp(-0.015) * (S > 100), 4)) last_day = 0.5 - day for hS, ht in [(1, day / 100), (0.1, day / 100), (0.01, day / 100), (0.01, day / 10)]: V_SS, res = residual(call, 100, last_day, hS, ht) print(hS, round(ht / day, 2), round(V_SS, 4), round(res, 4)) try: residual(call, 100, last_day, 1, day) except ZeroDivisionError as err: print("ZeroDivisionError:", err)

⌘/Ctrl + Enter runs the cell

The equation in Greeks

The three partials have names on a desk (case study 4.1.4): $V_t = \Theta$ , $V_S = \Delta$ and $V_{SS} = \Gamma$ . So the equation is a relation among the Greeks.

Rule: Black–Scholes in Greeks

\Theta + \tfrac{1}{2}\sigma^2S^2\,\Gamma + rS\,\Delta - rV = 0

With $\Theta$ per year, $\Gamma$ per dollar of stock, and $\sigma$ and $r$ as yearly decimals. It holds at every $(S, t)$ before expiry, for any option whose value the Black–Scholes equation describes.

With the closed forms of case studies 2.7.4 and 4.1.4, each row adds up to 0:

$(S, t)$	$V$	$\Theta$	$\frac{1}{2}\sigma^2S^2\Gamma$	$rS\Delta$	$-rV$
$(80, 0)$	0.3915	$-1.8731$	1.6914	0.1934	$-0.0117$
$(100, 0)$	6.3710	$-7.0738$	5.5544	1.7105	$-0.1911$
$(120, 0)$	22.0575	$-4.9932$	2.3117	3.3432	$-0.6617$
$(100, 0.25)$	4.3576	$-9.4352$	7.9168	1.6492	$-0.1307$
$(100, 0.45)$	1.8586	$-19.3245$	17.8134	1.5669	$-0.0558$

The algebra shows why. Case study 4.1.4 split theta into two parts, and each cancels one side of the rest:

1
$\Theta = -\frac{1}{2}\sigma^2S^2\Gamma - rKe^{-r(T - t)}N(d_2)$
2
$rS\Delta - rV = rKe^{-r(T - t)}N(d_2)$
3
$\Theta + \frac{1}{2}\sigma^2S^2\Gamma + rS\Delta - rV = 0$

10^{-12}

import math from scipy.stats import norm def greeks(S, t=0.0, K=100, T=0.5, r=0.03, sigma=0.2): tau = T - t d1 = (math.log(S / K) + (r + sigma**2 / 2) * tau) / (sigma * math.sqrt(tau)) d2 = d1 - sigma * math.sqrt(tau) value = S * norm.cdf(d1) - K * math.exp(-r * tau) * norm.cdf(d2) gamma = norm.pdf(d1) / (S * sigma * math.sqrt(tau)) theta = -S * norm.pdf(d1) * sigma / (2 * math.sqrt(tau)) - r * K * math.exp(-r * tau) * norm.cdf(d2) return value, norm.cdf(d1), gamma, theta r, sigma = 0.03, 0.2 for S, t in [(80, 0), (100, 0), (120, 0), (100, 0.25), (100, 0.45)]: V, delta, gamma, theta = greeks(S, t) terms = [theta, 0.5 * sigma**2 * S**2 * gamma, r * S * delta, -r * V] print(S, t, round(V, 4), [round(float(x), 4) for x in terms], abs(sum(terms)) < 1e-12)

⌘/Ctrl + Enter runs the cell

Theta pays for gamma

The equation has a desk reading. Hold the call and sell $\Delta$ shares against it, a delta hedge, with the cash from the sale earning the rate $r$ . Over a short time $dt$ , with a stock move $dS$ , the position gains about

\begin{gathered} \tfrac{1}{2}\Gamma\,(dS)^2 + \Theta\,dt - r(V - \Delta S)\,dt \\[4pt] = \tfrac{1}{2}\Gamma\left[(dS)^2 - \sigma^2S^2\,dt\right] \end{gathered}

The first line is case study 2.7.4's delta–gamma estimate with the delta term hedged away, plus theta and the interest on the cash. The equation turns it into the second line: the time decay and the interest together cost exactly $\frac{1}{2}\sigma^2S^2\Gamma\,dt$ .

So the hedged position breaks even when the stock moves by $\sigma S\sqrt{dt}$ , about one standard deviation: $1.0468 for a day. Smaller moves lose, larger moves gain. Repricing the call agrees:

stock move in a day	0	0.50	$\pm 1.0468$	$+2$	$-2$	$+3$
repriced gain	$-0.0152$	$-0.0119$	$\mp 0.0003$	0.0392	0.0416	0.1063
$\frac{1}{2}\Gamma[(dS)^2 - \sigma^2S^2dt]$	$-0.0152$	$-0.0117$	0	0.0403	0.0403	0.1098

What is left grows like the cube of the move, as in case study 2.7.4.

\sigma S\sqrt{dt}

⌘/Ctrl + Enter runs the cell

Check yourself

A trader holds a delta-hedged long call, as above. Over one day the stock moves by $0.50. Roughly what does the position make, interest included?

About 0.3 cents: gamma always earns money on a moveIt loses about 1.2 cents: the move is smaller than the break-even $1.05Nothing: the hedge removes all the risk

The put: same equation, another payoff

A put, the right to sell at the strike, satisfies the same equation; only the conditions change. At expiry it pays $\max(K - S, 0)$ , and for large $S$ it is worthless.

At $S = 0$ the ODE $V_t = rV$ now starts from $V(0, T) = K$ . So $V(0, t) = Ke^{-r(T - t)}$ : $98.5112 today.

The solution is the Black–Scholes put, $P = Ke^{-r(T - t)}N(-d_2) - SN(-d_1)$ , worth 4.8822 today: the price case study 5.11.4's tree closed in on. Its delta is $N(d_1) - 1 = -0.429842$ , its gamma is the call's, and its theta is

\Theta = -\frac{S\varphi(d_1)\sigma}{2\sqrt{T - t}} + rKe^{-r(T - t)}N(-d_2)

which is $-4.1184$ a year, $-0.0113$ a day. In the equation: $-4.1184 + 5.5544 - 1.2895 - 0.1465 = 0$ .

Put–call parity from the equation

The equation is linear, so the call minus the put, $C - P$ , is a solution too (lesson 6.3.1). Its terminal condition is $\max(S - K, 0) - \max(K - S, 0) = S - K$ .

A simpler solution has the same terminal value: $S - Ke^{-r(T - t)}$ . Both $S$ and $Ke^{-r(T - t)}$ solve the equation on their own, and at $t = T$ their difference is $S - K$ . A well-posed problem has only one solution (lesson 6.3.2), so

C - P = S - Ke^{-r(T - t)}

which is put–call parity (case study 3.3.4): $6.3710 - 4.8822 = 1.4888$ .

When theta is positive

Case study 4.1.4 found that a deep in-the-money put, at strike 130, gains 0.0064 a day as time passes. The equation says why: $\Theta = rV - rS\Delta - \frac{1}{2}\sigma^2S^2\Gamma$ .

For that put $V = 28.3235$ , $\Delta = -0.9534$ and gamma is small, 0.006897. So $\Theta = 0.8497 + 2.8601 - 1.3794 = 2.3304$ a year, or 0.0064 a day: the interest terms outweigh the gamma term.

S

import math import sympy as sp from scipy.stats import norm def put_greeks(S, K=100, tau=0.5, r=0.03, sigma=0.2): d1 = (math.log(S / K) + (r + sigma**2 / 2) * tau) / (sigma * math.sqrt(tau)) d2 = d1 - sigma * math.sqrt(tau) value = K * math.exp(-r * tau) * norm.cdf(-d2) - S * norm.cdf(-d1) gamma = norm.pdf(d1) / (S * sigma * math.sqrt(tau)) theta = -S * norm.pdf(d1) * sigma / (2 * math.sqrt(tau)) + r * K * math.exp(-r * tau) * norm.cdf(-d2) return value, norm.cdf(d1) - 1, gamma, theta for K in [100, 130]: P, delta, gamma, theta = put_greeks(100, K) terms = [theta, 0.5 * 0.2**2 * 100**2 * gamma, 0.03 * 100 * delta, -0.03 * P] print(K, round(P, 4), round(delta, 6), round(gamma, 6), round(theta, 4), round(theta / 365, 4), abs(sum(terms)) < 1e-12) S, t, r, sigma, K, T = sp.symbols("S t r sigma K T", positive=True) bs = lambda V: sp.simplify(sp.diff(V, t) + sigma**2 * S**2 / 2 * sp.diff(V, S, 2) + r * S * sp.diff(V, S) - r * V) print(bs(S), bs(K * sp.exp(-r * (T - t)))) d1 = (0.03 + 0.02) * 0.5 / (0.2 * math.sqrt(0.5)) C = 100 * norm.cdf(d1) - 100 * math.exp(-0.015) * norm.cdf(d1 - 0.2 * math.sqrt(0.5)) print(round(C - put_greeks(100)[0], 4), round(100 - 100 * math.exp(-0.015), 4))

⌘/Ctrl + Enter runs the cell

On the desk: conventions and traps

Theta per year. The equation needs $\Theta$ per year. Put in the per-day $-0.0194$ and the left side is 7.0544, not 0. A system that reports the slope in the time to expiry, $+7.0738$ , leaves 14.1475.
Decimals. $\sigma$ and $r$ are yearly decimals: $\sigma = 0.2$ , not 20.
A free consistency check. Any pricer for this model must satisfy the equation. A risk report whose $V$ , $\Delta$ , $\Gamma$ and $\Theta$ fail it has a bug, a stale number or a unit mismatch.
Before expiry only. At $t = T$ the payoff has a corner at the strike, and gamma and theta there are not defined. Near expiry, bump $S$ by much less than $S\sigma\sqrt{T - t}$ , and keep time steps short of expiry.
The model's assumptions. Constant $\sigma$ and $r$ , no dividends. With a continuous dividend yield $q$ (case study 6.1.4), $rS\,V_S$ becomes $(r - q)S\,V_S$ .
American options. The equation holds only where holding beats exercising. Case study 6.2.4 adds the exercise boundary for a put that never expires; case study 6.5.4 prices an American put on a grid.

Try it The traps of the note, with the six-month call's numbers: the per-day theta, the time-to-expiry sign, and the theta the equation implies.

import math from scipy.stats import norm S, r, sigma = 100, 0.03, 0.2 d1 = (r + sigma**2 / 2) * 0.5 / (sigma * math.sqrt(0.5)) d2 = d1 - sigma * math.sqrt(0.5) V = S * norm.cdf(d1) - 100 * math.exp(-0.015) * norm.cdf(d2) delta, gamma = norm.cdf(d1), norm.pdf(d1) / (S * sigma * math.sqrt(0.5)) theta = -S * norm.pdf(d1) * sigma / (2 * math.sqrt(0.5)) - r * 100 * math.exp(-0.015) * norm.cdf(d2) rest = 0.5 * sigma**2 * S**2 * gamma + r * S * delta - r * V print(round(theta / 365, 4), round(theta / 365 + rest, 4), round(-theta + rest, 4)) print(round(r * V - r * S * delta - 0.5 * sigma**2 * S**2 * gamma, 4))

⌘/Ctrl + Enter runs the cell

Check yourself

A pricer reports, for one option,

V = 6.3710

\Delta = 0.5702

\Gamma = 0.0278

and

\Theta = -0.0194

, with

S = 100

r = 0.03

and

\sigma = 0.2

. The left side of the Black–Scholes equation comes out at about 7.05. What is the likeliest cause?

The Black–Scholes formula does not satisfy its own equationGamma is quoted per 1% move of the stockTheta is per calendar day; per year it is

-7.07

, and the equation balances

Check yourself

The discounted payoff

e^{-r(T - t)}\max(S - K, 0)

equals the payoff at expiry. Why is it not the call's value before expiry?

Above the strike it fails the Black–Scholes equation, leaving a residual

rSe^{-r(T - t)}

It does not meet the terminal conditionIt is the value; the formula is an approximation to it

Exercise

Theta from the equation, and a report check

Write two functions.

implied_theta(V, delta, gamma, S, r, sigma, days=None) returns the theta the Black–Scholes equation implies, $\Theta = rV - rS\Delta - \frac{1}{2}\sigma^2S^2\Gamma$ , per year. If days is given (365 for calendar days, 252 for trading days), return it per day instead. Raise ValueError if S or sigma is not positive, or if days is given and not positive.
flag_reports(rows, tol=0.001) takes a list of risk-report rows. Each row is a dictionary with keys "V", "delta", "gamma", "theta", "S", "r" and "sigma", where "theta" is per calendar day. Return the positions (0, 1, 2, …) of the rows whose theta differs from the implied one by more than tol dollars a day.

The tests use the call and puts above, and a report with a per-year theta, a flipped sign and a per-trading-day theta.

See the tests

import math

from scipy.stats import norm


def _greeks(S, K, tau, r, sigma, kind="call"):
    """Value, delta, gamma and theta per year from the closed forms."""
    d1 = (math.log(S / K) + (r + sigma**2 / 2) * tau) / (sigma * math.sqrt(tau))
    d2 = d1 - sigma * math.sqrt(tau)
    gamma = norm.pdf(d1) / (S * sigma * math.sqrt(tau))
    vol_part = -S * norm.pdf(d1) * sigma / (2 * math.sqrt(tau))
    if kind == "call":
        value = S * norm.cdf(d1) - K * math.exp(-r * tau) * norm.cdf(d2)
        return value, norm.cdf(d1), gamma, vol_part - r * K * math.exp(-r * tau) * norm.cdf(d2)
    value = K * math.exp(-r * tau) * norm.cdf(-d2) - S * norm.cdf(-d1)
    return value, norm.cdf(d1) - 1, gamma, vol_part + r * K * math.exp(-r * tau) * norm.cdf(-d2)


def _row(S, K, tau, r, sigma, kind="call"):
    V, delta, gamma, theta = _greeks(S, K, tau, r, sigma, kind)
    return {"V": V, "delta": delta, "gamma": gamma, "theta": theta / 365, "S": S, "r": r, "sigma": sigma}


def test_call_per_year():
    """The six-month call implies theta −7.0738 a year"""
    V, delta, gamma, theta = _greeks(100, 100, 0.5, 0.03, 0.2)
    expect_close(implied_theta(V, delta, gamma, 100, 0.03, 0.2), theta, what="implied_theta for the six-month call", rel=1e-9)


def test_call_per_day():
    """Per calendar day it is −0.0194, and per trading day −0.0281"""
    V, delta, gamma, theta = _greeks(100, 100, 0.5, 0.03, 0.2)
    expect_close(implied_theta(V, delta, gamma, 100, 0.03, 0.2, days=365), theta / 365, what="implied_theta(..., days=365)", rel=1e-9)
    expect_close(implied_theta(V, delta, gamma, 100, 0.03, 0.2, days=252), theta / 252, what="implied_theta(..., days=252)", rel=1e-9)


def test_put():
    """The six-month put implies theta −4.1184 a year"""
    V, delta, gamma, theta = _greeks(100, 100, 0.5, 0.03, 0.2, kind="put")
    expect_close(implied_theta(V, delta, gamma, 100, 0.03, 0.2), theta, what="implied_theta for the put", rel=1e-9)


def test_deep_put_positive():
    """The deep in-the-money put (strike 130) has positive theta, 2.3304 a year"""
    V, delta, gamma, theta = _greeks(100, 130, 0.5, 0.03, 0.2, kind="put")
    expect_close(implied_theta(V, delta, gamma, 100, 0.03, 0.2), theta, what="implied_theta for the strike-130 put", rel=1e-9)


def test_other_option():
    """A one-year call on a $50 stock, strike 55, 35% volatility, 1% rate"""
    V, delta, gamma, theta = _greeks(50, 55, 1.0, 0.01, 0.35)
    expect_close(implied_theta(V, delta, gamma, 50, 0.01, 0.35), theta, what="implied_theta for the $50 stock", rel=1e-9)


def test_flags():
    """A report flags the per-year theta, the flipped sign and the per-trading-day theta, not the good rows"""
    good_call, good_put = _row(100, 100, 0.5, 0.03, 0.2), _row(100, 100, 0.5, 0.03, 0.2, kind="put")
    per_year = dict(good_call, theta=good_call["theta"] * 365)
    flipped = dict(good_call, theta=-good_call["theta"])
    trading = dict(good_call, theta=good_call["theta"] * 365 / 252)
    expect_equal(flag_reports([good_call, good_put, per_year, flipped, trading]), [2, 3, 4], what="flag_reports(rows)")


def test_flags_tolerance():
    """A theta off by half a cent a day is flagged at tol = 0.001 but not at tol = 0.01"""
    off = _row(100, 100, 0.5, 0.03, 0.2)
    off["theta"] += 0.005
    expect_equal(flag_reports([off]), [0], what="flag_reports([row off by 0.005])")
    expect_equal(flag_reports([off], tol=0.01), [], what="flag_reports([row off by 0.005], tol=0.01)")


def test_empty():
    """An empty report has nothing to flag"""
    expect_equal(flag_reports([]), [], what="flag_reports([])")


def test_bad_inputs():
    """A stock price or volatility that is not positive, or days = 0, raises ValueError"""
    for args, kwargs in [((6.37, 0.57, 0.028, 0, 0.03, 0.2), {}), ((6.37, 0.57, 0.028, 100, 0.03, 0), {}),
                         ((6.37, 0.57, 0.028, 100, 0.03, 0.2), {"days": 0})]:
        try:
            implied_theta(*args, **kwargs)
        except ValueError:
            continue
        raise AssertionError(f"implied_theta{args} with {kwargs} should raise ValueError")

V_t + \frac{1}{2}\sigma^2S^2V_{SS} + rSV_S - rV = 0

Case study: an option value fixed by its payoff

The Black–Scholes equation

Rule: The Black–Scholes equation

Which way it runs

Conditions: the payoff and the two ends

Rule: The call's conditions

Checking the formula by finite differences

A candidate that meets the payoff but fails

Close to expiry

The equation in Greeks

Rule: Black–Scholes in Greeks

Theta pays for gamma

The put: same equation, another payoff

Put–call parity from the equation

When theta is positive

Theta from the equation, and a report check

Summary card

Free further reading