What does Implied Volatility, Skew and Vertical Spreads conclude, in numbers, about “Black–Scholes–Merton Pricing and the Inversion of Implied Volatility”?

Answer: The Black–Scholes–Merton formula prices European options under constant volatility, lognormal returns and continuous frictionless trading, and can be implemented in the standard library with `math.erf`; the binomial tree converges to it as the number of steps grows. Implied volatility is a unique inverse with no closed form: Newton's method from the Manaster–Koehler start converges in every test case, about 15 % of cases fail from a fixed start, and bisection provides a fallback. The Brenner–Subrahmanyam approximation holds only at the money forward, where it is the first Newton step from zero. The next chapter looks at how markets price different strikes with different implied volatilities.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (16 programs), classical sources and the author's models and hypotheses; every price and trade in the book is fictional or illustrative.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python only

S = K100, 30 days, r = 3 %, sigma = 20 %: call 2.4096, put 2.1633
parity C - P0.246272; S - K exp(-rT) = 0.246272
with dividend yield q2 %: call 2.3237
CRR tree, European put: n10 50 250 1000 (formula)
2.10692.1519 2.1610 2.1627 (2.1633)
ATM-forward call,7 days: exact 1.1049, 0.3989*S*sigma*sqrt(T) = 1.1050
ATM-forward call,30 days: exact 2.2872, 0.3989*S*sigma*sqrt(T) = 2.2875
ATM-forward call,90 days: exact 3.9604, 0.3989*S*sigma*sqrt(T) = 3.9620
ATM-forward call, 365 days: exact 7.9656, 0.3989*S*sigma*sqrt(T)7.9788

Key formula

\[C = S e^{-qT} N(d_1) - K e^{-rT} N(d_2), \qquad P = K e^{-rT} N(-d_2) - S e^{-qT} N(-d_1),\]
Show the full program
# Black-Scholes-Merton prices with the normal CDF from math.erf, put-call parity, the
# Cox-Ross-Rubinstein tree converging to the formula, and the at-the-money shortcut.
# Illustrative parameters, not market quotes.
import math

def ncdf(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bsm(S, K, T, r, sig, q=0.0, kind="call"):
    d1 = (math.log(S / K) + (r - q + 0.5 * sig * sig) * T) / (sig * math.sqrt(T))
    d2 = d1 - sig * math.sqrt(T)
    if kind == "call":
        return S * math.exp(-q * T) * ncdf(d1) - K * math.exp(-r * T) * ncdf(d2)
    return K * math.exp(-r * T) * ncdf(-d2) - S * math.exp(-q * T) * ncdf(-d1)

def crr(S, K, T, r, sig, n, kind="put", american=False):
    dt = T / n
    u = math.exp(sig * math.sqrt(dt)); d = 1 / u
    p = (math.exp(r * dt) - d) / (u - d); disc = math.exp(-r * dt)
    pay = (lambda s: max(K - s, 0.0)) if kind == "put" else (lambda s: max(s - K, 0.0))
    v = [pay(S * u ** j * d ** (n - j)) for j in range(n + 1)]
    for i in range(n - 1, -1, -1):
        v = [disc * (p * v[j + 1] + (1 - p) * v[j]) for j in range(i + 1)]
        if american:
            v = [max(v[j], pay(S * u ** j * d ** (i - j))) for j in range(i + 1)]
    return v[0]

if __name__ == "__main__":
    S, K, T, r, sig = 100.0, 100.0, 30 / 365, 0.03, 0.20
    c, p = bsm(S, K, T, r, sig), bsm(S, K, T, r, sig, kind="put")
    print(f"S = K = 100, 30 days, r = 3 %, sigma = 20 %: call {c:.4f}, put {p:.4f}")
    print(f"parity C - P = {c - p:.6f};  S - K exp(-rT) = {S - K * math.exp(-r * T):.6f}")
    print(f"with dividend yield q = 2 %: call {bsm(S, K, T, r, sig, 0.02):.4f}")
    print("CRR tree, European put:   n = 10     50     250    1000   (formula)")
    vals = "  ".join(f"{crr(S, K, T, r, sig, n):.4f}" for n in (10, 50, 250, 1000))
    print(f"{'':26s}{vals}  ({p:.4f})")
    for days in (7, 30, 90, 365):
        t = days / 365
        k = S * math.exp(r * t)                    # at-the-money forward strike
        exact = bsm(S, k, t, r, sig)
        approx = S * sig * math.sqrt(t) / math.sqrt(2 * math.pi)
        print(f"ATM-forward call, {days:3d} days: exact {exact:.4f},"
              f" 0.3989*S*sigma*sqrt(T) = {approx:.4f}")

Single source and citation

Fan, Y. (2026). Implied Volatility Surfaces, Skew Premia and Quantitative Risk Control of Vertical Spreads (Version 1.0.0), Chapter 1: Black–Scholes–Merton Pricing and the Inversion of Implied Volatility. 5D Library. https://doi.org/10.5281/zenodo.23796765

DOI: 10.5281/zenodo.23796765 · Read the monograph · 5DL-B-038 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026038,
  author    = {Fan, Yafu},
  title     = {Implied Volatility Surfaces, Skew Premia and Quantitative Risk Control of Vertical Spreads},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  doi       = {10.5281/zenodo.23796765},
  url       = {https://doi.org/10.5281/zenodo.23796765}
}

Other chapter answers in this book