Volatility Arbitrage: Dispersion and Gamma Scalping

Volatility arbitrage is the business of trading the gap between the volatility an option implies and the volatility the underlying realizes, while hedging away the direction. There is nothing riskless about it — the "arbitrage" is a statistical edge with a fat left tail — but the P&L mechanics are exact and worth deriving, because every dispersion trade and every gamma scalp is the same equation applied at different scales. If you understand the delta-hedged option P&L, you understand the whole strategy family. This builds directly on the implied volatility surface and the Greeks.

The delta-hedged P&L identity

Buy an option, delta-hedge it continuously, and your P&L over a small step dt is, to second order:

dPnL ≈ 0.5 * Gamma * (dS)^2  +  Theta * dt   +  Vega * d(sigma)  + ...

If you mark the option at constant implied vol (no vega term) and rehedge frequently, the running P&L of a long, delta-hedged option is:

dPnL ≈ 0.5 * Gamma * S^2 * ( (dS/S)^2 - sigma_imp^2 * dt )

Read that carefully — it is the entire trade. (dS/S)^2 is realized variance over the step; sigma_imp^2 dt is the implied* variance you paid for via theta. Gamma is the conversion factor. So:

• Long option, delta-hedged: you make money when realized variance beats implied,

lose when it doesn't. You are long realized vol, short implied vol.

• Short option, delta-hedged: the mirror — short realized, long implied. You

collect theta and pray realized stays below implied.

Theta and gamma are two sides of one coin: Theta ≈ -0.5 Gamma S^2 * sigma_imp^2. You cannot be long gamma without paying theta. The trade is profitable only if the variance you harvest (gamma times realized moves squared) exceeds the variance you rented (theta). Everything else — dispersion, variance swaps — is packaging.

Gamma scalping, mechanically

Gamma scalping is the act of realizing the variance in that equation. You hold a long-gamma position (say a straddle), and as spot moves you rehedge the delta back to zero. Rehedging forces you to buy low and sell high mechanically: when spot rises, your delta goes positive, so you sell the underlying; when spot falls, delta goes negative, so you buy. Each rehedge locks in a small 0.5 Gamma (dS)^2 of P&L. The catch is the theta bleed running underneath.

import numpy as np
from scipy.stats import norm

def gamma_scalp_pnl(path, K, T, r, sigma_imp, rehedge_every=1, dt=1/252):
    """Simulate delta-hedged long-straddle P&L along a price path.
    Returns scalping gains net of theta, marking option at constant sigma_imp."""
    def bs_call(S, tau):
        if tau <= 0: return max(S-K, 0.0)
        d1 = (np.log(S/K) + (r + 0.5*sigma_imp**2)*tau)/(sigma_imp*np.sqrt(tau))
        d2 = d1 - sigma_imp*np.sqrt(tau)
        return S*norm.cdf(d1) - K*np.exp(-r*tau)*norm.cdf(d2)
    def delta(S, tau):
        if tau <= 0: return 1.0 if S > K else 0.0
        d1 = (np.log(S/K) + (r + 0.5*sigma_imp**2)*tau)/(sigma_imp*np.sqrt(tau))
        return norm.cdf(d1)

    n = len(path); tau = T
    # long 1 call + 1 put ~ straddle; track total delta hedge
    cash = 0.0
    opt0 = bs_call(path[0], tau) + bs_call(path[0], tau)  # placeholder structure
    hedge = -(2*delta(path[0], tau) - 1)   # straddle delta = 2N(d1)-1
    cash -= hedge * path[0]
    for i in range(1, n):
        tau = max(T - i*dt, 0.0)
        if i % rehedge_every == 0:
            new_hedge = -(2*delta(path[i], tau) - 1)
            cash -= (new_hedge - hedge) * path[i]
            hedge = new_hedge
    opt_T = max(path[-1]-K,0.0) + max(K-path[-1],0.0)
    return cash + hedge*path[-1] + opt_T - opt0

The single most important free parameter is rehedge frequency, and it is a genuine bias-variance tradeoff:

• Rehedge too often: you capture variance cleanly but pay the bid-ask spread and

slippage on every trade, and microstructure noise inflates measured "realized variance" with bounce that you cannot monetize.

• Rehedge too rarely: lower costs but higher P&L variance, and you carry directional

risk between hedges — a gap can turn a winning vol position into a losing day.

The continuous-hedging derivation says P&L is path-independent given realized variance; the discrete reality is that how the variance arrives (smooth grind vs one gap) and how often you touch it determine what you actually keep. See measuring volatility for why your realized-vol estimator and your hedge frequency must be consistent.

From single option to dispersion

A delta-hedged straddle is a pure bet on one name's realized-vs-implied. Dispersion trading is the index version: sell volatility on the index and buy volatility on the constituents (or vice versa). The reason this is a correlation trade comes from the variance identity for a portfolio:

Var(index) = sum_i w_i^2 * Var(i)  +  sum_{i!=j} w_i w_j * Cov(i,j)

Equivalently, in vol terms, index variance depends on average single-name variance and on the average pairwise correlation:

sigma_index^2 ≈ rho_bar * ( sum_i w_i * sigma_i )^2   (approx, equal-corr case)

So index implied vol bakes in an implied correlation. If you short index straddles and long constituent straddles (all delta-hedged), you are:

• Short index variance, long sum of single-name variance → net **short implied

correlation**. You profit when stocks move a lot individually but the index stays calm (low realized correlation) — the classic "single names dispersing" payoff.

Implied correlation is recoverable from the surface:

Quantity	Source	Interpretation
sigma_index	index ATM IV	market's index vol
sigma_i	each constituent ATM IV	single-name vols
rho_implied	solve variance identity	market-priced average correlation
rho_realized	trailing return correlation	what actually happened

The trade is long dispersion when rhoimplied is rich versus your forecast of rhorealized. Index vol is structurally bid (everyone hedges portfolios with index puts), which keeps implied correlation elevated above realized on average — that is the structural edge, and it is closely related to the broader volatility risk premium.

Correlation exposure is the real risk

Here is the asymmetry that defines the strategy and ruins the unprepared. Correlation is bounded: it cannot exceed 1. In a crash, everything correlates to 1 at once — single-name vols rise, but index vol rises more because the diversification that suppressed it evaporates. A short-correlation (long-dispersion) book is therefore implicitly short the crash: it bleeds or blows up exactly when the index gaps down and correlation spikes. The payoff profile of the whole trade is short-vol-like — many small gains, occasional large losses — even though it looks market-neutral day to day. This is the same short-gamma/short-tail signature you see across correlation trading.

Concretely, the dangers stacked on top of the headline correlation bet:

• Vega and gamma do not net cleanly. The index leg and the basket leg have

different vega per unit of notional and different gamma profiles; a move that is flat for the index can be large for a few names, so your "hedged" book has residual directional and convexity exposure that is largest precisely in turbulent markets.

• Constituent management. You rarely trade all 500 names — you trade a liquid

subset and accept basis risk against the true index. Reconstitutions, M&A, and single-name halts break the replication.

• Costs scale with the basket. Hedging dozens of single-name straddles is a

high-turnover operation; the transaction costs of rehedging the whole basket can exceed the implied-correlation premium you are trying to harvest. Capacity is real: you can only run dispersion at size where the single-name options are liquid enough to hedge.

Sizing the two legs: vega, gamma, or theta neutral?

A dispersion book has a structural choice that most write-ups skip: what do you neutralize between the index leg and the basket leg? You cannot be flat in everything at once, and the choice determines which risk you are actually expressing.

• Vega-neutral. Match the index and basket so a parallel shift in implied vol nets

to zero. This isolates the correlation bet and the implied-vs-realized term, which is usually the intent. But vega-neutral is not gamma-neutral, so you still carry a realized-vol exposure that has to be managed through delta rehedging.

• Gamma-neutral. Match second-order spot exposure so small moves net out. This kills

the gamma-scalping P&L on both legs and leaves you holding mostly vega and the correlation premium — appropriate if you want to be paid the static premium and avoid the path dependence, at the cost of giving up the realized-vol harvest.

• Theta-neutral. Match the daily decay so the book is self-financing day to day.

Tempting operationally but it lets vega and gamma drift, so it is rarely the primary constraint.

def dispersion_vega_weights(index_vega, name_vegas, name_corr_betas):
    # Scale single-name notionals so basket vega offsets index vega,
    # then tilt by each name's sensitivity to the correlation factor.
    base = index_vega / sum(name_vegas)
    return {nm: base * b for nm, b in zip(name_vegas, name_corr_betas)}

In practice desks run vega-neutral with a gamma overlay: neutralize the level of vol, then actively manage the residual gamma through rehedging frequency so they harvest single-name realized vol while staying short implied correlation. The weighting is not static — as spot and vols move, the vega and gamma of each leg drift, so the neutrality must be rebalanced, and that rebalancing is itself a cost that scales with the number of names in the basket. The more names, the better the correlation replication but the higher the maintenance cost; the sweet spot is a liquid subset of 20-50 names rather than the full index.

Honest edge decay and where it dies live

The implied-realized and implied-correlation gaps are persistent because they are risk premia, not mispricings — you are paid to warehouse the risk that vol and correlation spike. That means the edge cannot be diversified to zero and cannot be levered safely: the long-run Sharpe of naive short-vol/short-correlation is mediocre once you account for the drawdowns, and most of the realized losses arrive in a handful of days. Decay comes from crowding — when too much capital is short the same index variance, the premium compresses in calm regimes and the unwind amplifies the tail in stressed ones.

Practical survival rules: size to the tail, not the average (a short-vol book's "normal" daily vol radically understates its loss potential — use CVaR and stress scenarios and budget for correlation → 1); never run it unhedged against a deep-OTM index put or a long-vol overlay that caps the left tail; and account honestly for rehedging costs, because a backtest that assumes continuous frictionless hedging will show a beautiful Sharpe that does not survive contact with the order book. The mechanics are exact; the money is in respecting the path, the costs, and the crash.