What does Implied Volatility, Skew and Vertical Spreads conclude, in numbers, about “The Ratchet, the Kelly Criterion and Risks outside the Model”?

Answer: If each loss is capped and a fixed fraction is bet, trading capital never reaches zero in the geometric sense, but that does not make it safe. The Kelly fraction maximises long-run growth and brings deep drawdowns; beyond about twice the Kelly fraction growth turns negative. Following the author's confirmation, the book applies the three-tier ratchet only to incremental profit above the high-water mark: withdrawals come only from new highs, trading capital stays above its previous peak after every withdrawal, and skimming neither eats into existing capital nor changes the sign of the growth rate; but drawdowns of trading capital are the same as under full compounding, and losses can still take it below the starting stake. Skimming every winning trade is a trap: whenever \(0.4pb \le q\), trading capital has a negative long-run growth rate. Clustered losses, gaps, liquidity and margin, all outside the model, raise drawdowns substantially and can make growth negative.

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

win prob 0.45, win/loss 1.5: edge 0.125 per unit risked, Kelly fraction f*0.0833
f / f*0.25 0.5 1.0 1.5 2.0 2.5
g x 10002.27 3.87 5.15 3.89 0.14 -6.12
after 10 straight losses at f*: capital x 0.419 (never zero, since each loss <= f* < 1)
250 trades, 20,000 paths median: trading all P(drawdown >50%)
capital wealth trading trading+buffer
full compounding, f*/22.501 2.50 36.5% 36.5%
full compounding, f*3.268 3.27 97.2% 97.2%
full compounding, 2 f*0.845 0.85 100.0% 100.0%
ADOPTED: above high-water, f*/21.301 2.28 36.5% 18.4%
ADOPTED: above high-water, f*1.240 3.04 97.2% 70.8%
ADOPTED: above high-water, 2f*0.318 2.71 100.0% 98.6%
WARNING: per winning trade, f*0.001 1.41 100.0% 38.1%
high-water ratchet, every path: after each skim capital is still above the
old peak, and total skimmed1.5 x (HWM - start): f*/2 ok, f* ok, 2f* ok
but losses still bite: trading capital ends below its start in
27.2% of paths (f*/2), 41.0% of paths (f*), 69.4% of paths (2f*)
per-trade ratchet: log growth of trading capital -25.9 per 1000 per trade -> x 0.0015
long-run log growth of trading capital per 1000 trades f*/2 f*
full compounding (exact g)3.87 5.15
ratchet above high-water (one path, 2,000,000 trades)1.57 2.12

Key formula

\[C_{n+1} \ge (1 - f)\,C_n \quad\Longrightarrow\quad C_n \ge (1-f)^n C_0 > 0.\]
Show the full program
# Fixed-fraction sizing with a capped loss, the Kelly growth rate, and the author's
# three-tier ratchet: 30 % withdrawn, 30 % to a Treasury buffer at 3 %/yr, 40 % left to
# compound. ADOPTED RULE: the ratchet applies only to the part of trading capital above
# its high-water mark (HWM); a recovery back up to the old peak is never skimmed. Shown
# for contrast and as a WARNING: skimming 60 % of every winning trade. ILLUSTRATIVE
# trades: each risks a fraction f of trading capital; it loses the whole risk with
# prob. 0.55, or gains 1.5 x the risk.
import math, random

P, B, N_TRADES, PER_YEAR = 0.45, 1.5, 250, 50

def growth(f):              # expected log growth of trading capital per trade
    return P * math.log(1 + f * B) + (1 - P) * math.log(1 - f)

def run(f, ratchet, rng, n=N_TRADES):
    cap, buf, out, hwm = 1.0, 0.0, 0.0, 1.0
    peak, dd, peak2, dd2, ok = 1.0, 0.0, 1.0, 0.0, True
    for _ in range(n):
        buf *= math.exp(0.03 / PER_YEAR)
        gain = cap * f * (B if rng.random() < P else -1.0)
        skim = 0.0
        if ratchet == "trade" and gain > 0:
            skim = 0.6 * gain
        elif ratchet == "hwm" and cap + gain > hwm:
            skim = 0.6 * (cap + gain - hwm)
        out += skim / 2; buf += skim / 2; cap += gain - skim
        if ratchet == "hwm" and skim > 0:
            ok = ok and cap > hwm                  # still above the old peak after a skim
        hwm = max(hwm, cap)
        peak = max(peak, cap); dd = max(dd, 1 - cap / peak)
        peak2 = max(peak2, cap + buf); dd2 = max(dd2, 1 - (cap + buf) / peak2)
    if ratchet == "hwm":                           # all skims = 1.5 x (HWM - start)
        skimmed = out * 2                          # (buffer interest excluded)
        ok = ok and abs(skimmed - 1.5 * (hwm - 1.0)) < 1e-9 * max(1.0, hwm)
    return cap, buf, out, dd, dd2, ok

def long_run(f, ratchet, n=2000000, seed=7):
    # long-run log growth of trading capital per trade, from one long path; the state is
    # x = capital / HWM, since sizing is proportional the scale does not matter
    rng, x, lg = random.Random(seed), 1.0, 0.0
    for _ in range(n):
        y = x * (1 + f * (B if rng.random() < P else -1.0))
        if ratchet and y > 1:                  # new high: keep 40 % of the excess
            lg += math.log((1 + 0.4 * (y - 1)) / x); x = 1.0
        else:
            lg += math.log(y / x); x = min(y, 1.0) if ratchet else 1.0
    return lg / n

if __name__ == "__main__":
    k = P - (1 - P) / B
    print(f"win prob {P}, win/loss {B}: edge {P * B - (1 - P):.3f} per unit risked,"
          f" Kelly fraction f* = {k:.4f}")
    print("  f / f*     0.25   0.5    1.0    1.5    2.0    2.5")
    print("  g x 1000" + "".join(f"{1000 * growth(x * k):7.2f}" for x in
                                  (0.25, 0.5, 1.0, 1.5, 2.0, 2.5)))
    print(f"after 10 straight losses at f*: capital x {(1 - k) ** 10:.3f}"
          " (never zero, since each loss <= f* < 1)")
    print(f"{N_TRADES} trades, 20,000 paths  median: trading  all    P(drawdown >= 50%)")
    print("                                    capital  wealth   trading  trading+buffer")
    checks = []
    for lab, f, rat in (("full compounding, f*/2", k / 2, None),
                        ("full compounding, f*", k, None),
                        ("full compounding, 2 f*", 2 * k, None),
                        ("ADOPTED: above high-water, f*/2", k / 2, "hwm"),
                        ("ADOPTED: above high-water, f*", k, "hwm"),
                        ("ADOPTED: above high-water, 2f*", 2 * k, "hwm"),
                        ("WARNING: per winning trade, f*", k, "trade")):
        rng = random.Random(19); res = [run(f, rat, rng) for _ in range(20000)]
        med = lambda x: sorted(x)[len(x) // 2]
        cap = med([r[0] for r in res]); tot = med([r[0] + r[1] + r[2] for r in res])
        p50 = sum(r[3] >= 0.5 for r in res) / len(res)
        p2 = sum(r[4] >= 0.5 for r in res) / len(res)
        print(f"  {lab:31s}   {cap:7.3f}  {tot:6.2f}   {p50:6.1%}    {p2:6.1%}")
        if rat == "hwm":
            checks.append((lab.split(", ")[1], all(r[5] for r in res),
                           sum(r[0] < 1 for r in res) / len(res)))
    print("high-water ratchet, every path: after each skim capital is still above the")
    print("  old peak, and total skimmed = 1.5 x (HWM - start): "
          + ", ".join(f"{f} {'ok' if c else 'FAILED'}" for f, c, _ in checks))
    print("  but losses still bite: trading capital ends below its start in")
    print("  " + ", ".join(f"{b:.1%} of paths ({f})" for f, _, b in checks))
    g = P * math.log(1 + 0.4 * k * B) + (1 - P) * math.log(1 - k)
    print(f"per-trade ratchet: log growth of trading capital {1000 * g:+.1f} per 1000"
          f" per trade -> x {math.exp(N_TRADES * g):.4f}")
    print("long-run log growth of trading capital per 1000 trades      f*/2     f*")
    print(f"  full compounding (exact g)                              "
          f"{1000 * growth(k / 2):5.2f}  {1000 * growth(k):5.2f}")
    print(f"  ratchet above high-water (one path, 2,000,000 trades)   "
          f"{1000 * long_run(k / 2, True):5.2f}  {1000 * long_run(k, True):5.2f}")

Single source and citation

Fan, Y. (2026). Implied Volatility Surfaces, Skew Premia and Quantitative Risk Control of Vertical Spreads (Version 1.0.0), Chapter 6: The Ratchet, the Kelly Criterion and Risks outside the Model. 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