Variance Swaps: Replication and Trading

A variance swap exchanges future realized variance for a fixed strike, giving direct exposure to squared returns without the directional delta of a vanilla option. Its fair strike can be replicated by a continuum of out-of-the-money options, which makes it the clean theoretical expression of the volatility risk premium: investors often pay more for convex crash insurance than subsequent realized variance delivers.

Contract payoff and conventions

At maturity, a variance swap with variance notional N_var pays:

P&L = N_var * (RV - K_var)
RV = annualization * sum_i [log(S_ti / S_t(i-1))]^2

The annualization, sampling schedule, return definition, disruption rules, and corporate-action adjustments are all contractual. A “30-day variance” trade can differ materially between 252 and 365 annualization or between close-to-close and intraday sampling.

Exposure	Swap payoff	Conventional quote
Variance	linear in RV	variance points
Volatility	linear in sqrt(RV)	vol points
Vega notional	approximately linear near strike	dollars per vol point

Do not compare variance-swap returns directly with a straddle’s vega P&L without mapping notional and convexity.

Static replication

For a continuous diffusion with forward F and maturity T, the fair variance strike is:

K_var = (2 * exp(rT) / T) *
        [integral_0^F P(K,T)/K^2 dK + integral_F^infinity C(K,T)/K^2 dK]

The 1/K^2 weighting makes low-strike puts disproportionately important. This is not an arbitrary convention: it follows from the log contract identity and a dynamic delta hedge. It also explains why a sparse option chain or a poorly extrapolated left wing can overwhelm an apparently precise calculation.

Building a tradable estimate

Convert option mids to OTM prices, use the correct forward from funding/dividends, integrate over listed strikes, and extrapolate tails with an explicit model. Cboe-style VIX calculations use a discretized version:

import numpy as np

def variance_strike(strikes, otm_prices, forward, rate, maturity):
    dk = np.empty_like(strikes, dtype=float)
    dk[1:-1] = 0.5 * (strikes[2:] - strikes[:-2])
    dk[0], dk[-1] = strikes[1]-strikes[0], strikes[-1]-strikes[-2]
    integral = np.sum(dk * otm_prices / strikes**2)
    return 2 * np.exp(rate*maturity) * integral / maturity

This code is deliberately incomplete for production: it does not select the OTM put/call around the forward, handle zero bids, or extrapolate. Those choices should be tested as market-data sensitivity, not hidden inside a black-box “VIX” function.

Volatility is not variance

The volatility swap payoff is sqrt(RV) - K_vol. Jensen’s inequality means:

E[sqrt(RV)] < sqrt(E[RV])

The gap is the convexity adjustment. A first approximation using variance-of-variance is:

K_vol ≈ sqrt(K_var) - Var(RV) / (8 * K_var^(3/2))

It can be material in stressed markets. A variance swap cannot simply be relabeled as a vol swap at sqrt(K_var).

The trading P&L

A long variance swap accumulates realized variance each observation and reprices with the remaining implied variance:

MTM ≈ accrued_RV * elapsed/T
      + implied_remaining_variance * remaining/T
      - fixed_strike

This creates path dependence: two paths ending at the same spot can have radically different accrued P&L. It also means daily realized variance marks need clean adjusted closes and corporate-action treatment.

The replication is short a strip of OTM options when selling variance. Its apparent carry can vanish in a crash because jump variance is realized but cannot be delta hedged continuously. Position sizing should use jump scenarios, not a normal-distribution VaR.

Practical variants

Structure	Purpose	Main additional risk
Corridor variance	count variance only within spot range	range/path dependence
Gamma swap	weight returns by spot level	spot-variance correlation
Dispersion	long single-name, short index variance	correlation risk
Forward-start variance	isolate future period	forward-surface dynamics

Dispersion is often described as “selling correlation.” It is only approximately so: index weights, jumps, constituent skew, and rebalancing all affect the realized result.

Key takeaways

• Variance swaps are linear in realized variance, not realized volatility.
• Fair variance is replicated by OTM options weighted by inverse strike squared.
• Tail extrapolation and option-chain quality are first-order strike-estimation risks.
• Volatility swaps require a convexity adjustment.
• Selling variance harvests carry while retaining severe jump and liquidity exposure.