5D Library › Dealer Gamma Exposure, Zero-Day Options and Volatility Harvesting Dynamics · 中文
Chapter 4. Selling Volatility: the Win Rate Says Nothing, the Tail Says Everything
The popular claim
“Sell a 0DTE iron condor every day, win 85 % of the time, collect steady income.” The claim contains one true number and one false inference. The number is the win rate, which is easy to engineer: put the short strikes far enough out and most days end between them. The inference is that a high win rate means a positive or stable expectation. This chapter shows that the win rate carries essentially no information about the expectation, that the expectation is set by the price of the options relative to their true value, and that the danger of a genuine positive edge lies in its sizing rather than its sign.
The popular claim also has a pessimistic mirror — “a few gaps a year eat all the premium” — and that turns out to be wrong too, in an instructive way.
A model with gaps
The programs in this chapter use Merton’s jump-diffusion (Merton 1976): a diffusion with volatility 0.15 a year plus Poisson jumps three times a year, each of size Normal(−3 %, 1.5 %). A typical gap is therefore more than three daily standard deviations, which is the “3-sigma gap a few times a year” of trading folklore. Total realised volatility of the model is 0.1609.
The strategies sell one-day options each morning with strikes 1.45 diffusive daily standard deviations out of the money, chosen so that about 85 % of days are winners. The iron condor also buys wings 3.0 standard deviations out. The options are priced three ways: by Black-Scholes at 0.15, which ignores the jumps; at their true expected payoff under the model, which gives zero edge; and by Black-Scholes at 0.17, which builds in a variance premium of the kind documented for index options (Carr and Wu 2009).
Calculation
# Chapter 4. Selling one-day strangles and iron condors under jump diffusion
# (Merton). True model: daily log return = diffusion (sigma 0.15 a year) +
# Poisson jumps (3 a year, size Normal(mean -3 %, sd 1.5 %)): a 3-sigma-plus
# gap a few times a year. S = 100 each morning, r = 0. Strikes are set in
# DIFFUSIVE daily standard deviations (0.15 x sqrt(1/252) = 0.945 %): short
# put and call Z = 1.45 sd out of the money, so the strategy wins about 85 %
# of days; the condor adds long wings W = 3.0 sd out. Three ways the market
# might price the options:
# "diffusion only" Black-Scholes at 0.15: ignores the jumps entirely
# "fair" the true Merton expectation of each payoff: zero edge
# "with premium" Black-Scholes at 0.17: implied above realised (a
# variance premium)
import math
import random
T = 1 / 252
SIG, LAM, MJ, SJ = 0.15, 3.0, -0.03, 0.015
Z, W = 1.45, 3.0
def Phi(x):
return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
def bs(S, K, sig, T, call):
sd = sig * math.sqrt(T)
d1 = (math.log(S / K) + 0.5 * sd * sd) / sd
d2 = d1 - sd
if call:
return S * Phi(d1) - K * Phi(d2)
return K * Phi(-d2) - S * Phi(-d1)
def merton(S, K, T, call):
k = math.exp(MJ + 0.5 * SJ * SJ) - 1
tot = 0.0
for n in range(8):
w = math.exp(-LAM * T) * (LAM * T) ** n / math.factorial(n)
sig_n = math.sqrt(SIG * SIG + n * SJ * SJ / T)
S_n = S * math.exp(n * (MJ + 0.5 * SJ * SJ) - LAM * k * T)
tot += w * bs(S_n, K, sig_n, T, call)
return tot
def strikes():
sd = SIG * math.sqrt(T)
return (100 * math.exp(-Z * sd), 100 * math.exp(Z * sd),
100 * math.exp(-W * sd), 100 * math.exp(W * sd))
def premium(kind, price_mode):
sq = 0.17 if price_mode == "with premium" else SIG
kp, kc, wp, wc = strikes()
if price_mode == "fair":
f = lambda K, c: merton(100.0, K, T, c)
else:
f = lambda K, c: bs(100.0, K, sq, T, c)
prem = f(kp, False) + f(kc, True)
if kind == "condor":
prem -= f(wp, False) + f(wc, True)
return prem, (kp, kc, wp, wc)
def payoff(kind, ks, ST):
kp, kc, wp, wc = ks
loss = max(kp - ST, 0) + max(ST - kc, 0)
if kind == "condor":
loss -= max(wp - ST, 0) + max(ST - wc, 0)
return loss
def simulate(n_days, rng):
out = []
p_jump = 1 - math.exp(-LAM * T)
comp = -LAM * (math.exp(MJ + 0.5 * SJ * SJ) - 1) * T
for _ in range(n_days):
x = -0.5 * SIG * SIG * T + comp + rng.gauss(0, SIG * math.sqrt(T))
jumped = rng.random() < p_jump
if jumped:
x += rng.gauss(MJ, SJ)
out.append((100 * math.exp(x), jumped))
return out
def stats(pnl):
n = len(pnl)
m = sum(pnl) / n
sd = math.sqrt(sum((p - m) ** 2 for p in pnl) / (n - 1))
sk = sum((p - m) ** 3 for p in pnl) / n / sd ** 3
return m, sd, sk
if __name__ == "__main__":
rng = random.Random(56007)
days = simulate(252 * 200, rng)
print(
"200 simulated years, one trade a day; P&L in points per 100 of"
" underlying"
)
rows = []
for kind in ("strangle", "condor"):
for mode in ("diffusion only", "fair", "with premium"):
prem, ks = premium(kind, mode)
pnl = [prem - payoff(kind, ks, ST) for ST, _ in days]
jloss = sum(-p for p, (_, j) in zip(pnl, days) if j and p < 0)
jshare = jloss / (prem * len(days))
m, sd, sk = stats(pnl)
rows.append((kind, mode, prem, sum(p > 0 for p in pnl) / len(pnl),
m, sd, sk, min(pnl), m / sd * math.sqrt(252),
-min(pnl) / prem, jshare))
print("kind pricing premium win rate mean P&L sd")
for r in rows:
print(
"{:<9} {:<15}{:7.4f} {:7.3f} {:+8.4f} {:6.4f}".format(*r[:6])
)
print(
"\nkind pricing skew worst Sharpe/yr "
" worst/premium"
)
for r in rows:
print("{:<9} {:<15} {:+6.2f} {:8.3f} {:+8.2f} {:9.0f}".format(
r[0], r[1], *r[6:10]))
print("\nkind pricing share of premium repaid on jump days")
for r in rows:
print("{:<9} {:<15}{:8.3f}".format(r[0], r[1], r[10]))
nj = sum(j for _, j in days)
print(
"\njump days: {} of {} ({:.2f} a year)".format(
nj, len(days), nj / 200
)
)
print("realised volatility of the true model: {:.4f} a year".format(
math.sqrt(SIG ** 2 + LAM * (MJ ** 2 + SJ ** 2))))
# 200 simulated years, one trade a day; P&L in points per 100 of underlying
# kind pricing premium win rate mean P&L sd
# strangle diffusion only 0.0620 0.862 -0.0186 0.3146
# strangle fair 0.0822 0.867 +0.0015 0.3146
# strangle with premium 0.1019 0.873 +0.0212 0.3146
# condor diffusion only 0.0613 0.862 -0.0099 0.2286
# condor fair 0.0725 0.865 +0.0013 0.2286
# condor with premium 0.0992 0.872 +0.0280 0.2286
#
# kind pricing skew worst Sharpe/yr worst/premium
# strangle diffusion only -7.80 -7.054 -0.94 114
# strangle fair -7.80 -7.034 +0.08 86
# strangle with premium -7.80 -7.015 +1.07 69
# condor diffusion only -4.03 -1.434 -0.69 23
# condor fair -4.03 -1.423 +0.09 20
# condor with premium -4.03 -1.397 +1.94 14
#
# kind pricing share of premium repaid on jump days
# strangle diffusion only 0.311
# strangle fair 0.232
# strangle with premium 0.186
# condor diffusion only 0.170
# condor fair 0.142
# condor with premium 0.101
#
# jump days: 551 of 50400 (2.75 a year)
# realised volatility of the true model: 0.1609 a yearRead down the win-rate column first: 0.862, 0.867, 0.873 for the strangle and 0.862, 0.865, 0.872 for the condor. Then read the mean column: −0.0186, +0.0015 and +0.0212 for the strangle. The win rate barely moves while the expectation changes sign. The win rate is a property of where the strikes are; the expectation is a property of what the options cost.
A strangle priced at the diffusion-only value loses money on average despite winning 0.862 of days, because the price leaves out the gaps: a Sharpe ratio of −0.94 a year. Priced fairly, it earns nothing (+0.08, which is simulation noise). Only with a genuine premium is it profitable, at +1.07.
The tail columns explain the feeling of “steady income”. The distribution has a skewness of −7.80; the worst day loses 7.054 points per 100 of underlying, which is 86 days’ premium at the fair price and 69 days’ even with the premium.
Note
The condor’s higher Sharpe in the last row is an artefact. Its wings are bought at a flat 0.17, far below their true value under this model, so in that row the condor is long cheap insurance as well as short expensive options. Chapter 5 prices every option consistently and the comparison changes.
What a track record can show
If the edge is real but the losses are rare, a short record will usually miss them. The eighth program asks how often, and in which direction, a record misleads (a “peso problem”).
Calculation
# Chapter 4. What a short-volatility track record can show. Same true model
# and the same short strangle as p07 (strikes 1.45 diffusive sd out, quoted at
# 0.17 implied, so the strategy has a genuine positive edge). 4,000 simulated
# calendar years of 252 trades.
# Question: how often does a one-year or three-year record mislead, and in
# which direction? (A "peso problem": the rare loss is usually absent from a
# short sample.)
import math
import random
T = 1 / 252
SIG, LAM, MJ, SJ = 0.15, 3.0, -0.03, 0.015
Z, IV = 1.45, 0.17
def Phi(x):
return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
def bs(S, K, sig, call):
sd = sig * math.sqrt(T)
d1 = (math.log(S / K) + 0.5 * sd * sd) / sd
d2 = d1 - sd
return S * Phi(d1) - K * Phi(d2) if call else K * Phi(-d2) - S * Phi(-d1)
SD = SIG * math.sqrt(T)
KP, KC = 100 * math.exp(-Z * SD), 100 * math.exp(Z * SD)
PREM = bs(100.0, KP, IV, False) + bs(100.0, KC, IV, True)
P_JUMP = 1 - math.exp(-LAM * T)
COMP = -LAM * (math.exp(MJ + 0.5 * SJ * SJ) - 1) * T
def one_year(rng):
pnl, jumps = [], 0
for _ in range(252):
x = -0.5 * SIG * SIG * T + COMP + rng.gauss(0, SIG * math.sqrt(T))
if rng.random() < P_JUMP:
x += rng.gauss(MJ, SJ)
jumps += 1
ST = 100 * math.exp(x)
pnl.append(PREM - max(KP - ST, 0) - max(ST - KC, 0))
return pnl, jumps
def sharpe(p):
m = sum(p) / len(p)
sd = math.sqrt(sum((x - m) ** 2 for x in p) / (len(p) - 1))
return m / sd * math.sqrt(252)
if __name__ == "__main__":
rng = random.Random(56008)
years = [one_year(rng) for _ in range(4000)]
allp = [x for p, _ in years for x in p]
true_m = sum(allp) / len(allp)
print("premium per trade {:.4f}; long-run mean P&L per trade {:+.4f};"
.format(PREM, true_m))
print("long-run Sharpe {:+.2f}".format(sharpe(allp)))
tot = sorted(sum(p) for p, _ in years)
print("\nA. One-year outcomes (sum of 252 trades, points per 100)")
print(
" mean {:+.2f} median {:+.2f} 5th pct {:+.2f} worst {:+.2f}"
.format(
sum(tot) / len(tot),
tot[len(tot) // 2],
tot[len(tot) // 20],
tot[0],
)
)
print(
" share of losing years: {:.3f}".format(
sum(t < 0 for t in tot) / len(tot)
)
)
nj = [j for _, j in years]
print(" share of years with no jump: {:.3f} (Poisson: {:.3f})".format(
sum(j == 0 for j in nj) / len(nj), math.exp(-LAM)))
print(
"\nB. What a record shows, by the number of jumps it happened to"
" contain"
)
print(
" jumps in year share of years mean 1-yr Sharpe mean P&L/trade"
)
print(" vs truth")
for k in range(0, 6):
sel = [p for p, j in years if j == k]
if not sel:
continue
ms = sum(sum(p) / 252 for p in sel) / len(sel)
print(
" {:>8} {:9.3f} {:+10.2f} x {:5.2f}".format(
k,
len(sel) / len(years),
sum(sharpe(p) for p in sel) / len(sel),
ms / true_m,
)
)
print("\nC. Three-year records (non-overlapping blocks)")
blocks = [
sum((years[i + d][0] for d in range(3)), [])
for i in range(0, 3999, 3)
]
sh = sorted(sharpe(b) for b in blocks)
print(
" median 3-yr Sharpe {:+.2f}; share above 2.0: {:.3f}; share below"
" 0: {:.3f}".format(
sh[len(sh) // 2],
sum(s > 2.0 for s in sh) / len(sh),
sum(s < 0 for s in sh) / len(sh),
)
)
# premium per trade 0.1019; long-run mean P&L per trade +0.0205;
# long-run Sharpe +1.04
#
# A. One-year outcomes (sum of 252 trades, points per 100)
# mean +5.17 median +5.58 5th pct -3.65 worst -19.16
# share of losing years: 0.152
# share of years with no jump: 0.051 (Poisson: 0.050)
#
# B. What a record shows, by the number of jumps it happened to contain
# jumps in year share of years mean 1-yr Sharpe mean P&L/trade
# vs truth
# 0 0.051 +3.32 x 1.90
# 1 0.157 +2.43 x 1.61
# 2 0.223 +1.85 x 1.33
# 3 0.217 +1.28 x 1.00
# 4 0.167 +0.86 x 0.66
# 5 0.105 +0.46 x 0.32
#
# C. Three-year records (non-overlapping blocks)
# median 3-yr Sharpe +1.09; share above 2.0: 0.131; share below 0: 0.043The long-run Sharpe ratio of this strategy is +1.04. But a one-year record that happened to contain no jump — 0.051 of years, as the Poisson formula predicts — shows a mean Sharpe of +3.32 and overstates the true mean P&L by a factor of 1.90. A year with five jumps shows +0.46 and understates it by a factor of 0.32. Even three-year records are wide: 0.131 of them show a Sharpe above 2.0, and 0.043 are below zero. A trader with a good first year is, on this evidence, most likely a trader who had few gaps.
Evidence
What is known about option returns. Coval and Shumway found that index options earn returns far too low to be explained by their market risk alone — buying them loses money on average — consistent with a priced premium for bearing volatility or crash risk (Coval and Shumway 2001). Carr and Wu measured the variance risk premium directly and found it strongly negative for the S&P 500 index: implied variance exceeds subsequent realised variance on average (Carr and Wu 2009). Bondarenko argued that the high prices of index puts are hard to reconcile with standard models (Bondarenko 2014). These results support the “with premium” row as the relevant case for index options — over long samples. They do not say the premium is the same for 0DTE options, or that it is stable from year to year.
Sizing a skewed bet
A genuine edge with a −7.80 skew is a sizing problem. The ninth program uses the growth rate of the logarithm of wealth, the criterion behind Kelly sizing (Kelly 1956), with leverage defined as the notional sold per day divided by account equity.
Calculation
# Chapter 4. Sizing a positive-edge but negatively skewed bet. Same true model
# and the same short strangle quoted at 0.17 as p07/p08. Notional leverage L =
# underlying notional sold per day / account equity, so the account's daily
# return is L x P&L / 100. Growth rate g(L) = mean log(1 + L x P&L / 100) over
# 200 simulated years; a day with 1 + L x P&L / 100 <= 0 wipes the account
# out. Then: probability of a 50 % drawdown within five years, on 2,000
# simulated five-year paths, for several L.
import math
import random
T = 1 / 252
SIG, LAM, MJ, SJ = 0.15, 3.0, -0.03, 0.015
Z, IV = 1.45, 0.17
def Phi(x):
return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
def bs(S, K, sig, call):
sd = sig * math.sqrt(T)
d1 = (math.log(S / K) + 0.5 * sd * sd) / sd
d2 = d1 - sd
return S * Phi(d1) - K * Phi(d2) if call else K * Phi(-d2) - S * Phi(-d1)
SD = SIG * math.sqrt(T)
KP, KC = 100 * math.exp(-Z * SD), 100 * math.exp(Z * SD)
PREM = bs(100.0, KP, IV, False) + bs(100.0, KC, IV, True)
P_JUMP = 1 - math.exp(-LAM * T)
COMP = -LAM * (math.exp(MJ + 0.5 * SJ * SJ) - 1) * T
def day(rng):
x = -0.5 * SIG * SIG * T + COMP + rng.gauss(0, SIG * math.sqrt(T))
if rng.random() < P_JUMP:
x += rng.gauss(MJ, SJ)
ST = 100 * math.exp(x)
return PREM - max(KP - ST, 0) - max(ST - KC, 0)
def growth(L, sample):
tot = 0.0
for p in sample:
y = 1 + L * p / 100
if y <= 0:
return float("-inf")
tot += math.log(y)
return tot / len(sample) * 252
if __name__ == "__main__":
rng = random.Random(56009)
sample = [day(rng) for _ in range(252 * 200)]
worst = min(sample)
print("worst simulated day {:.3f} points per 100:".format(worst))
print("any L above {:.1f} is wiped out on it".format(-100 / worst))
best_L, best_g = 0.0, 0.0
for i in range(1, 400):
L = i * 0.05
g = growth(L, sample)
if g > best_g:
best_L, best_g = L, g
print(
"growth-optimal (Kelly) leverage L* = {:.2f}; growth {:+.3f} log"
" units a year".format(best_L, best_g)
)
print(
"\n L growth/yr P(50 % drawdown in 5 yrs) P(wiped out in"
" 5 yrs)"
)
for L in (
0.25 * best_L,
0.5 * best_L,
10.0,
best_L,
1.5 * best_L,
2 * best_L,
):
g = growth(L, sample)
dd = wipe = 0
for _ in range(2000):
eq, peak, hit = 1.0, 1.0, False
for _ in range(252 * 5):
eq *= max(0.0, 1 + L * day(rng) / 100)
if eq <= 0:
wipe += 1
hit = True
break
peak = max(peak, eq)
if eq < 0.5 * peak:
hit = True
dd += hit
print(
" {:5.2f} {:>8} {:7.3f} {:7.3f}"
.format(
L,
"-inf" if g == float("-inf") else "{:+.3f}".format(g),
dd / 2000,
wipe / 2000,
)
)
print(
"\nKelly estimated from a 10-year record instead (25 independent"
" records)"
)
ests = []
for _ in range(25):
rec = [day(rng) for _ in range(2520)]
bl, bg = 0.0, 0.0
for i in range(1, 600):
g = growth(i * 0.05, rec)
if g > bg:
bl, bg = i * 0.05, g
ests.append(bl)
ests.sort()
print(" estimated L*: min {:.2f}, median {:.2f}, max {:.2f}".format(
ests[0], ests[12], ests[-1]))
print(
" records whose estimated L* would be wiped out by the 200-year"
" worst"
)
print(" day: {} of 25".format(sum(L > -100 / worst for L in ests)))
# worst simulated day -7.352 points per 100:
# any L above 13.6 is wiped out on it
# growth-optimal (Kelly) leverage L* = 12.40; growth +0.406 log units a year
#
# L growth/yr P(50 % drawdown in 5 yrs) P(wiped out in 5 yrs)
# 3.10 +0.153 0.011 0.000
# 6.20 +0.278 0.301 0.000
# 10.00 +0.381 0.828 0.000
# 12.40 +0.406 0.959 0.001
# 18.60 -inf 0.998 0.135
# 24.80 -inf 1.000 0.635
#
# Kelly estimated from a 10-year record instead (25 independent records)
# estimated L*: min 5.40, median 13.85, max 22.90
# records whose estimated L* would be wiped out by the 200-year worst
# day: 13 of 25Three results stand out. First, the growth-optimal leverage is 12.40, while any leverage above 13.6 is wiped out by the worst simulated day: the optimum sits next to a cliff, and the cliff is located by a single observation, the worst day in the sample. Second, even at the optimum the probability of a 50 % drawdown within five years is 0.959; at half the optimum it is 0.301 and at a quarter 0.011. Third, and most important, the optimum has to be estimated. From 25 independent ten-year records the estimated optimum ranges from 5.40 to 22.90, and in 13 of the 25 the estimate lies beyond the cliff set by the 200-year worst day.
So the fragility of short volatility is not that its expectation is negative. In this model it is positive. The fragility is that the quantity that sets safe size — the depth of the worst loss — is the quantity a record is least able to measure.
Summary
The win rate of a short-volatility strategy is set by where its strikes are and says essentially nothing about its expectation, which is set by what the options cost relative to their true value: at 86-87 % win rates, the same strangle has a negative, zero or positive expectation depending only on price. Gaps do not eat all the premium — most is repaid on ordinary days — but they dominate the tail, where one day can cost 69 to 114 days’ premium. A positive edge is real for index options over long samples, but short records misstate it in both directions, and the growth-optimal size sits next to a cliff whose location a record cannot reliably measure.
References
Fan, Y. (2026). Dealer Gamma Exposure, Zero-Day Options and Volatility Harvesting Dynamics: Delta-Hedging Feedback Loops, Strike Pinning, Iron Condor Tail Ruin and Variance Swap Replication [做市商伽马敞口、零日到期期权与波动率收割动力学] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090160 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).