5D Library › Dealer Gamma Exposure, Zero-Day Options and Volatility Harvesting Dynamics · 中文

Chapter 2. The Hedging Feedback Loop and Strike Pinning

The one equation

Let a dealer’s net gamma inventory be GG shares per unit of price: when the price moves by dSdS, staying hedged means trading −GdS-G\,dS shares. Let each share traded move the price by λ\lambda. Write the product as one dimensionless number,

κ=λG.\kappa = \lambda G .

κ>0\kappa > 0 means the dealer is long gamma: to stay hedged it sells into rallies and buys into dips. κ<0\kappa < 0 means it is short gamma: it buys rallies and sells dips. The whole chapter follows from what happens when that trade feeds back into the price.

Calculation

Instant hedging. If the hedge trades at the same moment as the move it responds to, the observed move is the fundamental move dS0dS_0 plus the hedge’s own impact: dS=dS0−κdS⇒dS=dS01+κ.dS = dS_0 – \kappa\, dS \quad\Longrightarrow\quad dS = \frac{dS_0}{1+\kappa}. Realised volatility is scaled by 1/(1+κ)1/(1+\kappa): below one when the dealer is long gamma, above one when short. At κ=−1\kappa = -1 the equation has no finite solution — the price must jump.

Lagged hedging. If the hedge for the last move executes now, dSt=dS0,t−κdSt−1dS_t = dS_{0,t} – \kappa\, dS_{t-1}, an AR(1) process with lag-one autocorrelation −κ-\kappa and one-step variance σ2/(1−κ2)\sigma^2/(1-\kappa^2). Summed over many steps, the increments add up to ∑dS0/(1+κ)\sum dS_0/(1+\kappa), so over a long horizon volatility is again scaled by 1/(1+κ)1/(1+\kappa).

This is the same structure the literature on feedback effects from dynamic hedging found in continuous time (Frey and Stremme 1997; Platen and Schweizer 1998): hedgers who are long the options’ gamma lower the volatility of the underlying, hedgers who are short raise it, and the amplification diverges as the hedge’s market impact approaches the depth of the market.

A simulation, and a subtlety about horizons

Calculation

# Chapter 2. Delta-hedging feedback. A dealer with gamma inventory G must
# trade -G x (price change) shares to stay hedged; each share traded moves the
# price by lam. Write kappa = lam x G (dimensionless). Two timings are
# compared.
#   Instant hedging:  dS = dS0 - kappa dS     ->  dS = dS0 / (1 + kappa)
#   Lagged hedging:   dS_t = dS0_t - kappa dS_{t-1}   (hedge of the last move
#   executes now)
# kappa > 0: dealer LONG gamma (sells rallies, buys dips); kappa < 0: SHORT
# gamma. 390 one-minute steps a day, 2,000 simulated days per kappa, fixed
# seed.
import math
import random

# fundamental one-minute volatility
SIG_MIN = 0.20 / math.sqrt(252 * 390)
N_MIN, N_DAYS = 390, 2000

def simulate(kappa, lagged, rng):
    minute_var, daily = 0.0, []
    ac_num = ac_den = 0.0
    for _ in range(N_DAYS):
        prev, tot = 0.0, 0.0
        for _ in range(N_MIN):
            e = rng.gauss(0.0, SIG_MIN)
            d = e - kappa * prev if lagged else e / (1.0 + kappa)
            minute_var += d * d
            ac_num += d * prev
            ac_den += prev * prev
            tot += d
            prev = d
        daily.append(tot)
    mvar = minute_var / (N_DAYS * N_MIN)
    dvar = sum(x * x for x in daily) / N_DAYS
    return (
        math.sqrt(mvar) / SIG_MIN,
        math.sqrt(dvar / N_MIN) / SIG_MIN,
        ac_num / ac_den,
    )

if __name__ == "__main__":
    rng = random.Random(56003)
    print("A. Instant hedging: realised vol relative to fundamental vol")
    print("   kappa    simulated   theory 1/(1+kappa)")
    for k in (0.5, 0.2, 0.0, -0.2, -0.5, -0.8):
        m, d, ac = simulate(k, False, rng)
        print("   {:+5.1f}   {:9.3f}   {:9.3f}".format(k, d, 1 / (1 + k)))
    print(
        "   kappa <= -1: no finite solution; the price must jump (liquidity"
        " gap)"
    )

    print(
        "\nB. Lagged hedging: one-minute vol, daily vol, lag-1"
        " autocorrelation"
    )
    print("   kappa   1-min vol   theory   daily vol   theory    autocorr")
    for k in (0.5, 0.2, 0.0, -0.2, -0.5, -0.8):
        m, d, ac = simulate(k, True, rng)
        print(
            "   {:+5.1f}   {:8.3f}  {:7.3f}   {:8.3f}  {:7.3f}   {:+8.3f}"
            .format(k, m, 1 / math.sqrt(1 - k * k), d, 1 / (1 + k), ac)
        )
    print(
        "\nReading: long gamma (kappa > 0) cuts DAILY volatility and makes"
        " minute"
    )
    print(
        "returns mean-revert; short gamma raises daily volatility and makes"
        " them"
    )
    print(
        "trend. With lagged hedging, one-minute volatility rises in BOTH"
        " cases, so"
    )
    print(
        "the dampening of long gamma shows up at the daily horizon, not tick"
        " by tick."
    )
# A. Instant hedging: realised vol relative to fundamental vol
#    kappa    simulated   theory 1/(1+kappa)
#     +0.5       0.641       0.667
#     +0.2       0.816       0.833
#     +0.0       1.004       1.000
#     -0.2       1.218       1.250
#     -0.5       1.987       2.000
#     -0.8       5.240       5.000
#    kappa <= -1: no finite solution; the price must jump (liquidity gap)
#
# B. Lagged hedging: one-minute vol, daily vol, lag-1 autocorrelation
#    kappa   1-min vol   theory   daily vol   theory    autocorr
#     +0.5      1.154    1.155      0.684    0.667     -0.500
#     +0.2      1.021    1.021      0.851    0.833     -0.197
#     +0.0      1.001    1.000      0.984    1.000     +0.001
#     -0.2      1.021    1.021      1.251    1.250     +0.198
#     -0.5      1.154    1.155      1.958    2.000     +0.499
#     -0.8      1.664    1.667      4.937    5.000     +0.800
#
# Reading: long gamma (kappa > 0) cuts DAILY volatility and makes minute
# returns mean-revert; short gamma raises daily volatility and makes them
# trend. With lagged hedging, one-minute volatility rises in BOTH cases, so
# the dampening of long gamma shows up at the daily horizon, not tick by tick.

Section A matches the instant-hedging formula: at κ=+0.5\kappa = +0.5 realised volatility is 0.641 of its fundamental value against a theoretical 0.667; at κ=−0.8\kappa = -0.8 it is 5.240 against 5.000. The fit is loose at the extreme because one-day sums of a process that close to its stability boundary are themselves noisy.

Section B is the part worth stopping on. With lagged hedging, long gamma makes one-minute returns mean-revert (autocorrelation −0.500 at κ=+0.5\kappa = +0.5) and short gamma makes them trend (+0.499 at κ=−0.5\kappa = -0.5) — but one-minute volatility rises in both cases, to 1.154 times its fundamental value at κ=±0.5\kappa = \pm 0.5. Only at the daily horizon does the familiar asymmetry appear: 0.684 for long gamma and 1.958 for short.

So “long gamma dampens volatility” is a statement about the horizon at which volatility is measured. Measured tick by tick, a long-gamma market can look busier than a market with no hedgers at all; measured over the day, it is calmer. Any empirical test of the mechanism must say which horizon it uses.

Left: daily volatility relative to fundamental volatility, 1/(1+\kappa), and one-minute volatility under lagged hedging, 1/\sqrt{1-\kappa^2}, against \kappa. Right: the lag-one autocorrelation of returns under lagged hedging, -\kappa: mean reversion for long gamma, momentum for short.

Evidence

Evidence for the momentum half. Using index data, Baltussen, Da, Lammers and Martens found that the hedging demand of options market makers and leveraged exchange-traded funds predicts the market’s return in the last half-hour of the day in the direction of the day’s earlier move — intraday momentum — and that the effect is stronger when that hedging demand is larger (Baltussen et al. 2021). This is the short-gamma, lagged-hedging prediction in Section B, measured. At the single-stock level, Ni, Pearson, Poteshman and White found that the net gamma of option market makers is related to the volatility of the underlying stocks in the direction the hedging argument predicts (Ni et al. 2021).

Strike pinning

Near expiry, open interest concentrated at one strike creates a gamma spike (Chapter 1) exactly at that strike. Avellaneda and Lipkin showed that when hedgers are long that gamma and their trades have price impact, the stock price is attracted to the strike as expiry approaches (Avellaneda and Lipkin 2003). Their mechanism has two parts that appeared in Chapter 1: the gamma part (selling above the strike, buying below it) and the charm part (deltas decaying toward 0 or 1 on the clock).

The fourth program implements that mechanism directly. Dealers hold QQ calls struck at 100 and keep the hedge −QΔ-Q\Delta in shares; each share traded moves the price, so the traded price solves a fixed-point equation S=F−η[Δ(S,t)−Δ(S0,0)]S = F – \eta\,[\Delta(S,t) – \Delta(S_0,0)], where FF is the undisturbed price and η\eta is impact times position. Each simulated day starts uniformly within one point of the strike.

Calculation

# Chapter 2. Strike pinning on expiry day (an Avellaneda-Lipkin type
# mechanism). Dealers hold Q calls struck at K = 100 expiring at the 16:00
# close and keep the hedge -Q x delta in shares. Each share they trade moves
# the price, so the traded price S solves   S = F - eta x (delta(S, t) -
# delta(S0, 0)),   eta = (impact per share) x Q. F is the price the market
# would have shown without the hedge (a random walk). eta > 0: dealers LONG
# the calls (long gamma). eta < 0: dealers SHORT them. Each simulated day
# starts uniformly within +/- 1.00 of the strike; 5-minute steps; the close is
# read at 15:55. "Pinned" means |S_close - K| < 0.10 (0.1 % of price).
import math
import random

K, SIG = 100.0, 0.20
YEAR_MIN = 252 * 390.0
STEPS = 77                    # 5-minute steps from 09:35 to 15:55
DT = 5.0 / YEAR_MIN

def Phi(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def delta(S, T):
    return Phi((math.log(S / K) + 0.5 * SIG * SIG * T) / (SIG * math.sqrt(T)))

def gam(S, T):
    d1 = (math.log(S / K) + 0.5 * SIG * SIG * T) / (SIG * math.sqrt(T))
    return math.exp(-0.5 * d1 * d1) / (
        math.sqrt(2 * math.pi) * S * SIG * math.sqrt(T)
    )

def solve(F, eta, d0, T, s_prev):
    g = lambda s: s - F + eta * (delta(s, T) - d0)
    s = s_prev
    # Newton from the previous price
    for _ in range(30):
        slope = 1.0 + eta * gam(s, T)
        if slope <= 0.05:
            break
        step = g(s) / slope
        s -= step
        if abs(step) < 1e-9:
            return s, False
    # branch lost (only possible for eta < 0): scan for all roots, take the
    # nearest
    grid = [F - 3.0 + 0.01 * i for i in range(601)]
    roots, prev = [], g(grid[0])
    for a, b in zip(grid, grid[1:]):
        gb = g(b)
        if prev == 0 or prev * gb < 0:
            lo, hi, glo = a, b, prev
            for _ in range(40):
                mid = 0.5 * (lo + hi)
                gm = g(mid)
                if (gm < 0) == (glo < 0):
                    lo, glo = mid, gm
                else:
                    hi = mid
            roots.append(0.5 * (lo + hi))
        prev = gb
    return min(roots, key=lambda r: abs(r - s_prev)), True

def run(eta, n, rng):
    pinned, dist, jumps = 0, 0.0, 0
    for _ in range(n):
        S0 = K + rng.uniform(-1.0, 1.0)
        T0 = (STEPS + 1) * DT
        d0 = delta(S0, T0)
        F, S = S0, S0
        for i in range(STEPS):
            F += S0 * SIG * math.sqrt(DT) * rng.gauss(0.0, 1.0)
            T = (STEPS - i) * DT
            S_new, lost = solve(F, eta, d0, T, S)
            if lost:
                jumps += 1
            S = S_new
        pinned += abs(S - K) < 0.10
        dist += abs(S - K)
    return pinned / n, dist / n, jumps / n

if __name__ == "__main__":
    rng = random.Random(56004)
    N = 3000
    print(
        "eta      pinned share   mean |S_close - K|   branch losses per day"
    )
    for eta in (0.0, 0.10, 0.25, 0.50, -0.10, -0.25, -0.50):
        p, d, j = run(eta, N, rng)
        print(
            "{:+5.2f}      {:7.3f}          {:7.3f}             {:6.3f}"
            .format(eta, p, d, j)
        )
    print(
        "\nReading: with dealers long the strike (eta > 0) the close clusters"
        " at the"
    )
    print(
        "strike; with dealers short it (eta < 0) the close is pushed away. A"
        " branch"
    )
    print(
        "loss is a step at which the hedging feedback has no nearby stable"
        " price, so"
    )
    print("the price must jump to a distant solution.")
# eta      pinned share   mean |S_close - K|   branch losses per day
# +0.00        0.052            1.130              0.000
# +0.10        0.075            1.065              0.000
# +0.25        0.090            1.002              0.000
# +0.50        0.132            0.922              0.000
# -0.10        0.039            1.103              0.000
# -0.25        0.018            1.217              0.000
# -0.50        0.000            1.328              0.041
#
# Reading: with dealers long the strike (eta > 0) the close clusters at the
# strike; with dealers short it (eta < 0) the close is pushed away. A branch
# loss is a step at which the hedging feedback has no nearby stable price, so
# the price must jump to a distant solution.

With no dealer position (η=0\eta = 0), 0.052 of closes land within 0.10 of the strike. With dealers long the strike the share rises steadily, to 0.132 at η=+0.50\eta = +0.50 — about two and a half times the baseline — and the average distance of the close from the strike falls from 1.130 to 0.922. With dealers short, the strike repels: the pinned share falls to 0.018 at η=−0.25\eta = -0.25 and to 0.000 at η=−0.50\eta = -0.50.

At η=−0.50\eta = -0.50 something else happens: on 0.041 of steps per day the feedback equation loses the stable solution near the previous price and the price must jump to a distant one. That is the discrete-time version of the κ≤−1\kappa \le -1 boundary above, appearing locally near the strike as gamma becomes large enough there. In this model a short-gamma book does not merely add volatility; near a concentrated strike it creates gaps.

Share of simulated expiry-day closes within 0.10 of the strike, by dealer position \eta (values from the program above): the strike attracts when dealers are long it and repels when they are short.

Evidence

Evidence for pinning. Ni, Pearson and Poteshman documented that on option expiration dates the closing prices of optionable stocks cluster at strike prices, an effect absent in stocks without listed options, and attributed it to delta-hedge rebalancing by option market makers and firm proprietary traders and, in part, to stock-price manipulation by option writers (Ni et al. 2005). The direction of the hedging part matches Avellaneda and Lipkin’s long-gamma mechanism.

Hypothesis · not established

The author’s hypothesis (not established): on index expiry days, the share of closes within 0.1 % of the strike with the largest open interest is higher on days when dealers are long that strike’s gamma than on days when they are short it, where the dealers’ position is measured from signed trade data rather than inferred from open interest. What would show it to be wrong: no difference, or the reverse, when the sign is measured; and if a difference appears only when the sign is inferred by the open-interest convention, the convention is doing the work, not the mechanism (Chapter 3).

Summary

Hedging feedback is one line of algebra: with κ=λG\kappa = \lambda G, realised volatility is scaled by 1/(1+κ)1/(1+\kappa), long gamma calms the market and short gamma excites it, and at κ=−1\kappa = -1 the price must jump. With lagged hedging the same mechanism appears as mean reversion (long gamma) or momentum (short gamma) in short-horizon returns, while short-horizon volatility rises in both cases — the calming effect of long gamma is a statement about the daily horizon. Near expiry the same feedback pins the price to a strike held long by dealers and repels it from a strike held short, where it can also produce gaps. All of this takes the dealers’ sign as given. The next chapter asks whether anyone outside the dealers can know it.

References

Avellaneda, Marco, and Michael D. Lipkin. 2003. “A Market-Induced Mechanism for Stock Pinning.” Quantitative Finance 3 (6): 417–25.
Baltussen, Guido, Zhi Da, Sten Lammers, and Martin Martens. 2021. “Hedging Demand and Market Intraday Momentum.” Journal of Financial Economics 142 (1): 377–403.
Frey, Rüdiger, and Alexander Stremme. 1997. “Market Volatility and Feedback Effects from Dynamic Hedging.” Mathematical Finance 7 (4): 351–74.
Ni, Sophie Xiaoyan, Neil D. Pearson, and Allen M. Poteshman. 2005. “Stock Price Clustering on Option Expiration Dates.” Journal of Financial Economics 78 (1): 49–87.
Ni, Sophie Xiaoyan, Neil D. Pearson, Allen M. Poteshman, and Joshua White. 2021. “Does Option Trading Have a Pervasive Impact on Underlying Stock Prices?” The Review of Financial Studies 34 (4): 1952–86.
Platen, Eckhard, and Martin Schweizer. 1998. “On Feedback Effects from Hedging Derivatives.” Mathematical Finance 8 (1): 67–84.

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