5D Library › Implied Volatility Surfaces, Skew Premia and Quantitative Risk Control of Vertical Spreads · 中文
Chapter 2 The Volatility Surface, Skew and the Variance Risk Premium
From one number to a surface
If the Black–Scholes–Merton assumptions held, every option on the same underlying with the same expiry would imply the same volatility. They do not. Laid out by strike and expiry, implied volatilities form an undulating surface: for a given expiry, the implied volatility of equity index options usually rises as the strike falls, giving a downward-sloping “skew”, and across expiries there is a term structure. Rubinstein (1994) noted that this shape became pronounced and persistent in US index options after the crash of October 1987 (Rubinstein 1994); Gatheral’s practitioner’s guide discusses the shape, dynamics and models of the surface systematically (Gatheral 2006).
Markets summarise the shape of one expiry’s smile with a few numbers. Measuring moneyness by delta, the 25-delta risk reversal is the implied volatility of the call with delta 0.25 minus that of the put with delta −0.25,
so a negative value means the put side is dearer, a negative skew; the 25-delta butterfly is the average of the two minus the at-the-money volatility, measuring the curvature (“smile”).
How jumps produce skew
Merton (1976) added Poisson jumps to geometric Brownian motion: on average jumps per unit of time, each with a normally distributed log size of mean and standard deviation (Merton 1976). If jump risk is not priced, a European option is a Poisson-weighted sum of Black–Scholes prices:
with , , and .
The program below prices 30-day options under three illustrative sets of risk-neutral parameters, inverts each strike’s price to a Black–Scholes implied volatility, and finds the 25-delta and 10-delta strikes, risk reversals and butterfly. Finally it checks the series formula independently with 400,000 Monte Carlo paths.
Calculation
# Merton (1976) jump-diffusion prices -> Black-Scholes implied volatilities across
# strikes, the 25-delta risk reversal and butterfly, and a Monte Carlo check.
# Risk-neutral parameters are ILLUSTRATIVE, not fitted to any market.
import math, random
def ncdf(x):
return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
def bs_put(S, K, T, r, s):
d1 = (math.log(S / K) + (r + 0.5 * s * s) * T) / (s * math.sqrt(T))
return K * math.exp(-r * T) * ncdf(-d1 + s * math.sqrt(T)) - S * ncdf(-d1)
def merton_put(S, K, T, r, s, lam, mj, dj, nmax=40):
k = math.exp(mj + 0.5 * dj * dj) - 1; lp = lam * (1 + k) * T
tot, w = 0.0, math.exp(-lp)
for n in range(nmax):
sn = math.sqrt(s * s + n * dj * dj / T)
rn = r - lam * k + n * math.log(1 + k) / T
tot += w * bs_put(S, K, T, rn, sn)
w *= lp / (n + 1)
return tot
def iv_put(P, S, K, T, r, lo=1e-4, hi=3.0):
for _ in range(80):
mid = 0.5 * (lo + hi)
lo, hi = (mid, hi) if bs_put(S, K, T, r, mid) < P else (lo, mid)
return 0.5 * (lo + hi)
def smile(S, T, r, s, lam, mj, dj):
f = lambda K: iv_put(merton_put(S, K, T, r, s, lam, mj, dj), S, K, T, r)
def strike_at(delta): # put delta -0.25 or call delta +0.25
lo, hi = 50.0, 160.0
for _ in range(60):
K = 0.5 * (lo + hi); v = f(K)
d1 = (math.log(S / K) + (r + 0.5 * v * v) * T) / (v * math.sqrt(T))
dlt = ncdf(d1) - (1 if delta < 0 else 0)
lo, hi = (K, hi) if dlt > delta else (lo, K)
return K, v
atm = f(S * math.exp(r * T))
return f, [strike_at(d) for d in (-0.25, 0.25, -0.10, 0.10)], atm
S, T, r = 100.0, 30 / 365, 0.03
MODELS = {"no jumps": (0.18, 0.0, 0.0, 0.0), "symmetric jumps": (0.15, 0.5, 0.0, 0.10),
"crash-type jumps": (0.15, 0.5, -0.10, 0.10)}
if __name__ == "__main__":
print("30-day implied vol by strike K = 85 90 95 100 105 110")
out = {}
for name, (s, lam, mj, dj) in MODELS.items():
f, ks, atm = smile(S, T, r, s, lam, mj, dj); out[name] = (ks, atm)
print(f" {name:28s}" + "".join(f"{f(K):7.3f}" for K in range(85, 111, 5)))
print(" 25D put K/vol 25D call K/vol ATM RR25 BF25 RR10")
for name, (((kp, vp), (kc, vc), (_, v10p), (_, v10c)), atm) in out.items():
rr25, bf, rr10 = (round(x, 3) + 0 for x in (vc - vp, 0.5 * (vp + vc) - atm,
v10c - v10p))
print(f" {name:17s} {kp:6.2f}/{vp:.3f} {kc:6.2f}/{vc:.3f} {atm:.3f}"
f" {rr25:+.3f} {bf:+.3f} {rr10:+.3f}")
s, lam, mj, dj = MODELS["crash-type jumps"]
rng = random.Random(1976); k = math.exp(mj + 0.5 * dj * dj) - 1; n = 400000
pay = pay2 = 0.0
for _ in range(n):
x = (r - lam * k - 0.5 * s * s) * T + s * math.sqrt(T) * rng.gauss(0, 1)
u, t = rng.random(), math.exp(-lam * T) # Poisson draw by inversion
j, c = 0, t
while u > c:
j += 1; t *= lam * T / j; c += t
x += sum(rng.gauss(mj, dj) for _ in range(j))
v = max(90 - S * math.exp(x), 0); pay += v; pay2 += v * v
mc, se = pay / n, math.sqrt((pay2 / n - (pay / n) ** 2) / n)
exact = merton_put(S, 90, T, r, s, lam, mj, dj)
print(f"check, crash-type jumps, K = 90 put: series {exact:.4f}")
print(f" Monte Carlo {math.exp(-r * T) * mc:.4f} (SE {se:.4f}, {n:,} paths)")
# 30-day implied vol by strike K = 85 90 95 100 105 110
# no jumps 0.180 0.180 0.180 0.180 0.180 0.180
# symmetric jumps 0.227 0.186 0.164 0.159 0.163 0.181
# crash-type jumps 0.285 0.232 0.185 0.165 0.159 0.160
# 25D put K/vol 25D call K/vol ATM RR25 BF25 RR10
# no jumps 96.95/0.180 103.94/0.180 0.180 +0.000 +0.000 +0.000
# symmetric jumps 97.29/0.160 103.53/0.161 0.159 +0.001 +0.001 +0.003
# crash-type jumps 97.06/0.174 103.51/0.160 0.164 -0.013 +0.003 -0.038
# check, crash-type jumps, K = 90 put: series 0.1407
# Monte Carlo 0.1399 (SE 0.0019, 400,000 paths)Without jumps every strike implies 0.180 and the surface is flat. Symmetric jumps with zero mean lift both wings into a “smile”: 0.227 at strike 85 and 0.181 at 110, 0.159 near the money, with a risk reversal of almost zero. Setting the mean jump to −10 % (“crash-type” jumps) tilts the curve to the left: 0.285 at 85 and 0.160 at 110. Figure 1 plots the three curves.
One point is easily missed. The 25-delta risk reversal for crash-type jumps is only −0.013 (−1.3 vol points), because the 25-delta strikes of a 30-day option (97.06 and 103.51) lie only about 3 % from the spot; the 10-delta risk reversal is −0.038, and the implied volatility at strike 85 is about 12 points above at-the-money. The 25-delta risk reversal measures the slope near the money; tail pricing has to be read from strikes further out. The Monte Carlo check gives 0.1399 (standard error 0.0019), in line with the series value of 0.1407.
Fat tails: three models
Mandelbrot pointed out in 1963 that changes in speculative prices show far more extreme values than a normal distribution allows (Mandelbrot 1963); Blattberg and Gonedes (1974) compared stable and Student distributions and found the latter better for daily returns (Blattberg and Gonedes 1974). Cont (2001) collected the empirical regularities of asset returns as “stylised facts”, among them heavy tails, volatility clustering and “aggregational Gaussianity”, the tendency of returns to look more normal at longer horizons (Cont 2001).
The program below simulates 400 years of daily returns with the same daily standard deviation (1 %) under four models: normal, Student’s t with 4 degrees of freedom (rescaled), Merton jumps, and GARCH(1,1) volatility clustering. It counts the days per decade with falls beyond 3, 4 and 5 standard deviations, then sums returns over 21 days to see whether monthly tails survive.
Calculation
# Fat tails in SIMULATED daily returns with the same 1 % daily standard deviation:
# normal, Student t (4 d.f., rescaled), Merton jumps, GARCH(1,1) volatility clustering.
# How often does a "k-sigma" day occur, and do tails survive aggregation to 21 days?
import math, random
def draws(model, n, rng, sd=0.01):
if model == "normal":
return [rng.gauss(0, sd) for _ in range(n)]
if model == "Student t, 4 df":
c = sd / math.sqrt(4 / 2) # var of t(4) is 4 / (4 - 2) = 2
return [c * rng.gauss(0, 1) / math.sqrt(rng.gammavariate(2, 2) / 4)
for _ in range(n)]
if model == "jumps (Merton)":
lam, mj, dj = 3 / 252, -0.04, 0.02 # ~3 jumps a year, mean -4 %
s = math.sqrt(sd * sd - lam * (mj * mj + dj * dj))
out = []
for _ in range(n):
x = rng.gauss(0, s) - lam * mj # jumps add mean-zero noise on average
if rng.random() < lam:
x += rng.gauss(mj, dj)
out.append(x)
return out
a, b = 0.08, 0.90; w = sd * sd * (1 - a - b); h = sd * sd; out = []
for _ in range(n): # GARCH(1,1), normal shocks
x = math.sqrt(h) * rng.gauss(0, 1); out.append(x); h = w + a * x * x + b * h
return out
def kurt(x):
m = sum(x) / len(x); v = sum((y - m) ** 2 for y in x) / len(x)
return sum((y - m) ** 4 for y in x) / len(x) / v ** 2
if __name__ == "__main__":
rng = random.Random(2001); n = 252 * 400 # 400 simulated years per model
print(f"{'':16s} kurtosis days per 10 years below 21-day sums: kurtosis,")
print(f"{'':16s} (normal 3) -3 sd -4 sd -5 sd share below -3 sd")
for m in ("normal", "Student t, 4 df", "jumps (Merton)", "GARCH(1,1)"):
x = draws(m, n, rng); sd = math.sqrt(sum(y * y for y in x) / n)
per10 = [2520 * sum(y < -k * sd for y in x) / n for k in (3, 4, 5)]
mo = [sum(x[i:i + 21]) for i in range(0, n - 20, 21)]
msd = math.sqrt(sum(y * y for y in mo) / len(mo))
share = sum(y < -3 * msd for y in mo) / len(mo)
k3, k4, k5 = per10
print(f"{m:16s} {kurt(x):6.1f} {k3:6.2f} {k4:6.2f} {k5:6.2f}"
f" {kurt(mo):5.1f}, {100 * share:.2f} %")
nd = [2520 * 0.5 * (1 + math.erf(-k / math.sqrt(2))) for k in (3, 4, 5)]
print(f"{'normal, exact':16s} 3.0 {nd[0]:6.2f} {nd[1]:6.2f} {nd[2]:6.3f}"
" 3.0, 0.13 %")
# kurtosis days per 10 years below 21-day sums: kurtosis,
# (normal 3) -3 sd -4 sd -5 sd share below -3 sd
# normal 3.0 3.12 0.10 0.00 3.0, 0.15 %
# Student t, 4 df 23.2 16.88 6.12 2.75 4.1, 0.27 %
# jumps (Merton) 10.5 20.27 14.75 9.32 3.2, 0.33 %
# GARCH(1,1) 4.3 10.12 2.00 0.40 4.9, 0.48 %
# normal, exact 3.0 3.40 0.08 0.001 3.0, 0.13 %Under the normal distribution, falls beyond four standard deviations occur on about 0.08 days a decade (0.10 in the simulation) and beyond five essentially never; under Student’s t the counts are 6.12 and 2.75 days, and under the jump model 14.75 and 9.32. Summed over 21 days, the kurtosis of the independent t and jump returns falls to 4.1 and 3.2, close to the normal value of 3: aggregational Gaussianity. GARCH kurtosis instead rises to 4.9, and 0.48 % of its months fall by more than three standard deviations, 3.7 times the normal rate. Monthly tail risk thus comes mainly from volatility clustering, not just from fat-tailed single days. The sample kurtosis of the t returns (23.2) is very unstable, because with four degrees of freedom the theoretical kurtosis is infinite.
Note
Student’s t cannot be used directly for pricing. If the log return has a Student t distribution, is infinite, and forward and call prices become meaningless. The book therefore uses the t distribution only to compare tail frequencies and computes option prices with jump-diffusion; pricing with t-like tails requires truncation or a distribution whose tails decay exponentially.
Chapter summary
Implied volatility varies with strike and expiry, forming a surface that for equity indexes usually slopes down to the left. Crash-type jumps can produce such a skew, but the 25-delta risk reversal reflects only the slope near the money. Fat tails are pronounced at the daily horizon, while monthly tails come mainly from volatility clustering; Student’s t cannot be used directly for pricing. There is substantial evidence for variance and skew premia in index options, weaker evidence for single stocks; the premia vary over time and are disputed, and the seller’s average gain comes with extreme negative skewness.
References
Fan, Y. (2026). Implied Volatility Surfaces, Skew Premia and Quantitative Risk Control of Vertical Spreads: Microstructure Pricing and Time-Stop Dynamics under Non-Gaussian Tails [期权隐含波动率曲面、偏度溢价与垂直价差结构的定量风控] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23796765 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).