5D Library › 做市商伽马敞口、零日到期期权与波动率收割动力学 · English
第四章 卖出波动率:胜率什么都没说,尾部说明一切
流行的说法
「每天卖一张 0DTE 铁鹰,85% 的时候赢,稳拿现金流。」这句话包含一个真实的数字和一个错误的推论。数字是胜率,它很容易被造出来:把卖出的行权价放得足够远,大多数日子就会收在两者之间。推论是高胜率意味着正的或稳定的期望。本章说明:胜率几乎不携带关于期望的任何信息;期望由期权相对其真实价值的价格决定;而一份真实的正向优势,其危险在于注码,而不在于符号。
这个流行说法还有一个悲观的镜像——「一年几次缺口就把权利金全吃光」——它同样是错的,而且错得很有启发性。
一个带缺口的模型
本章程序使用默顿跳跃扩散模型 (Merton 1976):年波动率 0.15 的扩散,加上每年三次的泊松跳跃,每次大小服从 Normal(−3%, 1.5%)。所以典型的缺口超过三个日标准差,就是交易圈所说的「一年几次 3-Sigma 缺口」。模型的总已实现波动率为 0.1609。
策略每天早上卖出一日期权,行权价放在 1.45 个扩散日标准差之外,使约 85% 的日子盈利。铁鹰另外买入 3.0 个标准差之外的保护翼。期权用三种方式定价:按 0.15 的布莱克-斯科尔斯,忽略跳跃;按模型下的真实期望支付,即零优势;按 0.17 的布莱克-斯科尔斯,内含指数期权文献所记录的那种方差溢价 (Carr and Wu 2009)。
推导
# 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 year先往下看胜率一栏:宽跨式为 0.862、0.867、0.873,铁鹰为 0.862、0.865、0.872。再看均值一栏:宽跨式为 −0.0186、+0.0015、+0.0212。胜率几乎不动,期望却变了号。胜率是行权价位置的属性;期望是期权价格的属性。
按只含扩散的价值定价的宽跨式,尽管 0.862 的日子盈利,平均仍在亏钱,因为价格漏掉了缺口:年化夏普比率 −0.94。按公允价值定价,它什么也赚不到(+0.08,是模拟噪声)。只有存在真实溢价时它才盈利,为 +1.07。
尾部各栏解释了「稳定现金流」的感觉从何而来。分布的偏度为 −7.80;最差的一天每 100 名义亏损 7.054 点,在公允价格下相当于 86 天的权利金,即使有溢价也相当于 69 天。
注
末行铁鹰较高的夏普比率是一个假象。 它的保护翼按统一的 0.17 买入,远低于这个模型下保护翼的真实价值,所以在那一行里,铁鹰既卖出了昂贵的期权,又买入了便宜的保险。第五章对每一张期权一致定价,比较结果随之改变。
缺口并没有吃光全部权利金
最后一栏回答了悲观的版本。公允价格下,跳跃日的亏损偿还了全部所收权利金的 0.232;有溢价时为 0.186。其余部分——绝大部分——是在普通日子里偿还的:一次扩散性的波动直接穿过了卖出的行权价。在 200 个模拟年里共有 551 个跳跃日,每年 2.75 个。
所以两句口号都不对。卖波动率的人既不是只因缺口而获得报酬,也不是只因缺口而破产。要紧的是溢价是否超过全部亏损的真实价值;对一个确有溢价的卖方而言,要紧的是每笔交易押上多少。
一份交易记录能说明什么
如果优势是真的、而亏损罕见,一份短的记录通常会错过它们。第八段程序问:记录有多常误导人,朝哪个方向误导(「比索问题」)。
推导
# 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.043这个策略的长期夏普比率为 +1.04。但恰好没有跳跃的一年——占 0.051,与泊松公式的预测一致——平均显示 +3.32 的夏普比率,把真实的平均盈亏高估到 1.90 倍。有五次跳跃的一年显示 +0.46,把它低估到 0.32 倍。即使是三年的记录也很分散:0.131 的三年记录夏普比率超过 2.0,0.043 低于零。按这份证据,一个第一年做得很好的交易者,最可能只是一个那年缺口很少的交易者。
证据
关于期权收益已知的情况。 Coval 与 Shumway 发现,指数期权的收益低得无法只用其市场风险解释——买入它们平均亏钱——这与承担波动率或崩盘风险获得定价溢价相一致 (Coval and Shumway 2001)。Carr 与 Wu 直接测量了方差风险溢价,发现标普 500 指数的方差风险溢价显著为负:隐含方差平均高于随后的已实现方差 (Carr and Wu 2009)。Bondarenko 论证了指数认沽的高价格难以用标准模型解释 (Bondarenko 2014)。这些结果支持把「有溢价」那一行当作指数期权的相关情形——在长样本上。它们并没有说 0DTE 期权的溢价也一样,也没有说溢价逐年稳定。
为一个偏斜的赌注定注码
偏度 −7.80 的真实优势是一个注码问题。第九段程序使用财富对数的增长率——凯利注码背后的准则 (Kelly 1956)——杠杆 定义为每天卖出的名义本金除以账户权益。
推导
# 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 25有三个结果很突出。第一,增长最优杠杆为 12.40,而任何高于 13.6 的杠杆都会被模拟中最差的一天清零:最优点就挨着悬崖,而悬崖的位置由一个观测值决定——样本中最差的那一天。第二,即便在最优点,五年内出现 50% 回撤的概率也有 0.959;最优点的一半为 0.301,四分之一为 0.011。第三,也是最重要的,最优点必须被估计。从 25 份相互独立的十年记录估出的最优点在 5.40 到 22.90 之间,其中 25 份里有 13 份的估计值落在由 200 年最差一天确定的悬崖之外。
所以卖波动率的脆弱性不在于期望为负。在这个模型里期望是正的。脆弱性在于:决定安全规模的那个量——最大亏损的深度——恰恰是一份记录最无法测量的量。
小结
卖波动率策略的胜率由行权价的位置决定,对其期望几乎什么都没说;期望由期权相对真实价值的价格决定:在 86-87% 的胜率下,同一张宽跨式仅因价格不同而有负、零或正的期望。缺口并没有吃光全部权利金——大部分在普通日子里偿还——但它们主宰尾部,一天就可能抵掉 69 到 114 天的权利金。对指数期权而言,在长样本上正向优势是真实的,但短记录会在两个方向上误报它,而增长最优的规模挨着一道悬崖,悬崖的位置是记录无法可靠测量的。
参考文献
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).