What does Tail Protection under Kelly Bounds conclude, in numbers, about “Quantile Hedging: Which Part of the Tail to Protect First on a Limited Budget”?

Answer: Chapter 4 shows that quantile hedging aimed at the success probability abandons the deep tail, so that with the same budget the probability of capital below 0.6 rises from 0.00415 to 0.00480.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (20 programs), classical sources and the author's hypotheses.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.00415, 0.00480, 0.6

budget 0.00470 = 40 % of full cover 0.01176
planP(M<TAU)E shortfallES 0.975P(M'<0.6)E log M'
no cover0.05950.006320.33720.004150.14024
quantile0.01430.003310.28690.004800.13985
linear0.01430.003310.28690.004800.13985
proportional0.03570.003790.26700.000220.13970
log growth0.01700.003390.28770.002680.13994
frontierquantile: P(M<TAU)ES 0.975 | log: P(M<TAU)ES 0.975
0.20.02520.3373|0.02750.3256
0.40.01430.2869|0.01700.2877
0.60.00730.2377|0.00880.2409
0.80.00250.1932|0.00290.1951
1.00.00000.1618|0.00000.1618
Show the full program
# Chapter 4. p42: one budget, four objectives, different tails.
# Same grid, operator and budget as p41. Covers c (0 <= c <= D) bought
# at exp(-R) * q per unit in each bin; the premium B is paid by every
# strategy, so M' = M - B + c. Strategies: quantile hedge (max success
# probability), linear shortfall (max p / q first), proportional cover
# (a plain protection struck where M = TAU), and log growth (maximise
# E log M' by water-filling). Then a budget frontier. Illustrative.
import math

MU, SIG = 0.05, 0.18
LAM, JM, JS = 0.10, -0.35, 0.15
R, LAMQ = 0.03, 0.20
A, L, TAU = 0.12, 1.0, 0.85
DF = math.exp(-R)


def Phi(x):
    return 0.5 * math.erfc(-x / math.sqrt(2.0))


def comps(mu, lam):
    kap = math.exp(JM + 0.5 * JS * JS) - 1.0
    base = mu - 0.5 * SIG * SIG - lam * kap
    return [(math.exp(-lam) * lam ** n / math.factorial(n), base + n * JM,
             math.sqrt(SIG * SIG + n * JS * JS)) for n in range(13)]


def cdf(cs, x):
    return math.fsum(w * Phi((x - m) / s) for w, m, s in cs)


CP, CQ = comps(MU, LAM), comps(R, LAMQ)
E = [-4.0 + 0.02 * i for i in range(261)]
FP = [0.0] + [cdf(CP, e) for e in E[1:260]] + [1.0]
FQ = [0.0] + [cdf(CQ, e) for e in E[1:260]] + [1.0]
S = [math.exp(0.5 * (E[i] + E[i + 1])) for i in range(260)]
P = [FP[i + 1] - FP[i] for i in range(260)]
Q = [FQ[i + 1] - FQ[i] for i in range(260)]
M = [1.0 + A + L * (s - 1.0) for s in S]
D = [max(TAU - m, 0.0) for m in M]
FULL = DF * math.fsum(q * d for q, d in zip(Q, D))


def greedy(key, budget):
    c, left = [0.0] * 260, budget
    for i in sorted((i for i in range(260) if D[i] > 0), key=key):
        cost = DF * Q[i] * D[i]
        f = min(1.0, left / cost)
        c[i] = f * D[i]
        left = max(0.0, left - f * cost)
        if left <= 0.0:
            break
    return c


def log_fill(budget):
    def cov(nu):
        return [min(D[i], max(0.0, P[i] / (nu * DF * Q[i]) - (M[i] - budget)))
                if Q[i] > 0 else 0.0 for i in range(260)]
    lo, hi = -20.0, 20.0
    for _ in range(200):
        mid = 0.5 * (lo + hi)
        cost = DF * math.fsum(q * x for q, x in zip(Q, cov(math.exp(mid))))
        lo, hi = (mid, hi) if cost > budget else (lo, mid)
    return cov(math.exp(hi))


def report(c, budget):
    mp = [m - budget + x for m, x in zip(M, c)]
    fail = math.fsum(P[i] * (1.0 - c[i] / D[i]) for i in range(260)
                     if D[i] > 0)
    short = math.fsum(p * (d - x) for p, d, x in zip(P, D, c))
    tail, need, acc = sorted(zip(mp, P)), 0.025, []
    for m, p in tail:
        use = min(p, need)
        acc.append(use * (1.0 - m))
        need -= use                  # step
        if need <= 0.0:
            break
    deep = math.fsum(p for m, p in zip(mp, P) if m < 0.6)
    g = math.fsum(p * math.log(m) for m, p in zip(mp, P))
    return fail, short, math.fsum(acc) / 0.025, deep, g


B = 0.40 * FULL
plans = [("no cover", [0.0] * 260, 0.0),
         ("quantile", greedy(lambda i: -P[i] / (Q[i] * D[i]), B), B),
         ("linear", greedy(lambda i: -P[i] / Q[i], B), B),
         ("proportional", [0.40 * d for d in D], B),
         ("log growth", log_fill(B), B)]
print("budget {:.5f} = 40 % of full cover {:.5f}".format(B, FULL))
print("plan          P(M<TAU)  E shortfall  ES 0.975  P(M'<0.6)  E log M'")
for name, c, b in plans:
    f, sh, es, dp, g = report(c, b)
    print("{:12s}  {:.4f}    {:.5f}     {:.4f}    {:.5f}    {:.5f}".format(
        name, f, sh, es, dp, g))
print("frontier   quantile: P(M<TAU)  ES 0.975 | log: P(M<TAU)  ES 0.975")
for share in (0.2, 0.4, 0.6, 0.8, 1.0):
    b = share * FULL
    f1, _, e1, _, _ = report(greedy(lambda i: -P[i] / (Q[i] * D[i]), b), b)
    f2, _, e2, _, _ = report(log_fill(b), b)
    print("  {:.1f}               {:.4f}     {:.4f}  |      {:.4f}     {:.4f}"
          .format(share, f1, e1, f2, e2))

Single source and citation

Fan, Y. (2026). Tail-Risk Option Moats and Quantile Hedging: Jump-Diffusion Models and Fixed-Premium Protection of Core Cash Flows under Kelly Bounds (Version 1.0.0), Chapter 4: Quantile Hedging: Which Part of the Tail to Protect First on a Limited Budget. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-290 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026290,
  author    = {Fan, Yafu},
  title     = {Tail-Risk Option Moats and Quantile Hedging: Jump-Diffusion Models and Fixed-Premium Protection of Core Cash Flows under Kelly Bounds},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book