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

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 year

Read 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.

Distribution of daily P&L of the short strangle quoted at 0.17 over 200 simulated years, on a log scale: a wall of small gains and a long thin tail of losses. (An independent simulation of the same model, so its extremes differ slightly from the table.)

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.

The gaps do not eat all the premium

The last column answers the pessimistic version. At the fair price, the losses on jump days repay 0.232 of all the premium collected; with the premium, 0.186. The rest — the large majority — is repaid on ordinary days when a diffusive move simply goes through a short strike. Over 200 simulated years there were 551 jump days, 2.75 a year.

So neither slogan is right. The short-volatility seller is not paid for gaps alone, and is not ruined by gaps alone. What matters is whether the premium exceeds the true value of all the losses, and for a seller with a genuine premium, how much is risked on each trade.

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.043

The 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 LL 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 25

Three 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.

Growth rate of log wealth against leverage for the same strategy (an independent simulated sample). The curve peaks just before the dashed line, the leverage at which the sample’s worst day wipes the account out; beyond it growth is minus infinity.

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

Bondarenko, Oleg. 2014. “Why Are Put Options so Expensive?” Quarterly Journal of Finance 4 (3): 1450015.
Carr, Peter, and Liuren Wu. 2009. “Variance Risk Premiums.” The Review of Financial Studies 22 (3): 1311–41.
Coval, Joshua D., and Tyler Shumway. 2001. “Expected Option Returns.” The Journal of Finance 56 (3): 983–1009.
Kelly, Jr., John L. 1956. “A New Interpretation of Information Rate.” Bell System Technical Journal 35 (4): 917–26. https://doi.org/10.1002/j.1538-7305.1956.tb03809.x.
Merton, Robert C. 1976. “Option Pricing When Underlying Stock Returns Are Discontinuous.” Journal of Financial Economics 3 (1–2): 125–44. https://doi.org/10.1016/0304-405X(76)90022-2.

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).