Dispersion Trading: Profiting from Volatility Differences

What Is Dispersion Trading?

Definition: Dispersion trading exploits the gap between index volatility (e.g., SPX, NDX) and the average volatility of the index's components (individual stocks like AAPL, MSFT, GOOGL).

The Core Insight

Index volatility depends on:

1. Component volatilities: How much each stock moves
2. Correlation: How much stocks move together

Mathematical relationship:

Key Insight: When correlation (ρ) is high (stocks move together), index vol ≈ average component vol. When correlation is low (stocks move independently), index vol < component vol.

The Trade:

• When correlation is high: Index vol is "rich" relative to components → Sell index vol, buy component vol
• When correlation is low: Index vol is "cheap" relative to components → Buy index vol, sell component vol

Who Uses This Strategy?

The Math: Why Index Vol ≠ Sum of Component Vols

Simple Example: 2-Stock Index

Imagine an index with 2 stocks, equal weighted (50% each):

• Stock A volatility: 30%
• Stock B volatility: 30%

Scenario 1: Perfect correlation (ρ = 1.0)

• Index volatility = 30% (same as components)
• No dispersion opportunity

Scenario 2: Zero correlation (ρ = 0)

• Index volatility = √(0.5² × 30² + 0.5² × 30²) = 21.2%
• Dispersion = 30% - 21.2% = 8.8%
• Trade: Buy index straddle (cheap vol at 21%), sell A and B straddles (rich vol at 30%)

Scenario 3: Negative correlation (ρ = -0.5)

• Index volatility = 18.4%
• Dispersion = 30% - 18.4% = 11.6% (even bigger)

Why Dispersion Exists

Strategy Mechanics: Long Index, Short Components

Classic Dispersion Trade

Setup: SPX is trading at $4,000, 30-day implied vol is 20%

Step 1: Buy Index Straddle

• Buy 1 SPX 4000 call @ $80 (20% IV)
• Buy 1 SPX 4000 put @ $80 (20% IV)
• Total cost: $16,000 (80 × 2 × $100 multiplier)
• Exposure: Long volatility, long gamma, short theta

Step 2: Sell Component Straddles (Delta-Weighted)

SPX has 500 stocks, but top 10 make up 30%+ of the index. Sell straddles on the largest components:

Step 3: Delta Hedge

• The straddles have net delta (not perfectly ATM)
• Hedge by buying/selling SPY or /ES futures to get to delta-neutral
• Goal: P&L driven by volatility, not direction

Step 4: Rehedge Daily

• As SPX moves, delta changes (gamma risk)
• Adjust hedge daily to stay delta-neutral
• Cost: Transaction costs (0.01-0.05% per rehedge)

Profit Scenarios

Loss Scenario

Case Study: Citadel's March 2020 Dispersion Trade

Background

In March 2020, Citadel's Wellington and Tactical Trading funds reportedly made over $3 billion from volatility strategies, with dispersion trading as a key component.

The Setup (Early March 2020)

The Trade

Early March (before panic): Buy long-dated SPX straddles (cheap), sell shorter-dated component straddles (rich)

Position (hypothetical $10M notional):

• Long 100 SPX 3000 straddles (June expiry) @ $300 = $3M debit
• Short 500 component straddles (April expiry) across AAPL, MSFT, AMZN, GOOGL, etc. @ $25 avg = $1.25M credit
• Net debit: $1.75M

What Happened

1. Correlation collapsed: Tech stocks (AMZN, NFLX, ZM) surged, travel/oil (AAL, XOM) crashed → ρ dropped from 0.80 to 0.50
2. Index vol spiked faster: Institutions panic-bought SPX puts → VIX hit 82%, SPX straddles doubled in value
3. Realized dispersion exploded: Individual stocks realized 100%+ vol, but SPX realized "only" 70-80%

The Exit (Late March)

March 23 (bottom):

• SPX straddles worth $600 (from $300) → +$30M profit
• Component straddles worth $40 (from $25) → -$7.5M loss
• Net P&L: +$22.5M on $1.75M risk = +1,286% return

Calendar Dispersion: Exploiting Vol Term Structure

What Is Calendar Dispersion?

Instead of trading index vs components, trade near-term vs long-term dispersion:

• Front-month dispersion: Usually lower (short-term correlations high)
• Long-dated dispersion: Usually higher (long-term correlations lower, more uncertainty)

Trade: Sell front-month dispersion (collect theta), buy long-dated dispersion (tail hedge)

When Calendar Dispersion Works

Python Implementation

Calculate SPX Dispersion

import yfinance as yf
import pandas as pd
import numpy as np

def calculate_dispersion(index_ticker='SPY', components=None, days=30):
    """
    Calculate implied volatility dispersion
    """
    if components is None:
        # Top 10 SPX components (simplified)
        components = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'NVDA',
                      'META', 'TSLA', 'BRK-B', 'UNH', 'JNJ']

    # Get index IV (using HV as proxy, or fetch IV from options chain)
    index_data = yf.Ticker(index_ticker).history(period=f'{days*2}d')
    index_returns = index_data['Close'].pct_change()
    index_vol = index_returns.std() * np.sqrt(252) * 100  # Annualized %

    # Get component IVs
    component_vols = []
    weights = []

    for ticker in components:
        try:
            data = yf.Ticker(ticker).history(period=f'{days*2}d')
            returns = data['Close'].pct_change()
            vol = returns.std() * np.sqrt(252) * 100
            component_vols.append(vol)

            # Equal weight (simplified; real calc uses market cap weights)
            weights.append(1 / len(components))
        except:
            print(f"Error fetching {ticker}")
            continue

    # Weighted average component vol
    avg_component_vol = np.average(component_vols, weights=weights)

    # Dispersion
    dispersion = avg_component_vol - index_vol

    # Implied correlation (simplified)
    # σ_index² = Σw²σ² + ΣΣww'ρσσ'
    # For equal weights: ρ ≈ (σ_index² - σ_avg²/n) / (σ_avg²(1-1/n))
    n = len(components)
    implied_corr = (index_vol**2 - avg_component_vol**2 / n) / (avg_component_vol**2 * (1 - 1/n))

    return {
        'index_vol': index_vol,
        'avg_component_vol': avg_component_vol,
        'dispersion': dispersion,
        'implied_correlation': implied_corr,
        'component_vols': dict(zip(components, component_vols))
    }

# Run the scanner
result = calculate_dispersion()
print(f"Index Vol: {result['index_vol']:.2f}%")
print(f"Avg Component Vol: {result['avg_component_vol']:.2f}%")
print(f"Dispersion: {result['dispersion']:.2f}% pts")
print(f"Implied Correlation: {result['implied_correlation']:.2f}")

if result['dispersion'] > 5:
    print("\n🚨 HIGH DISPERSION - Consider LONG dispersion trade")
elif result['dispersion'] < 2:
    print("\n✅ LOW DISPERSION - Consider SHORT dispersion trade")
else:
    print("\n➡️ NORMAL DISPERSION - No clear signal")

Backtest Framework

import yfinance as yf
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def backtest_dispersion_strategy(start_date='2015-01-01', capital=100000):
    """
    Simple dispersion backtest:
    - Long dispersion when dispersion > 6%
    - Short dispersion when dispersion < 3%
    """
    spy = yf.download('SPY', start=start_date)['Adj Close']

    # Calculate rolling 30-day dispersion
    results = []

    for i in range(60, len(spy), 5):  # Check every 5 days
        end_date = spy.index[i]
        start_calc = spy.index[i-60]

        # Calculate dispersion
        disp = calculate_dispersion(days=30)

        # Signal
        if disp['dispersion'] > 6:
            signal = 'LONG'  # Buy index straddles, sell component straddles
            expected_return = 0.03  # Avg 3% return if dispersion closes
        elif disp['dispersion'] < 3:
            signal = 'SHORT'  # Sell index straddles, buy component straddles
            expected_return = 0.02  # Avg 2% return from theta
        else:
            signal = 'NEUTRAL'
            expected_return = 0

        results.append({
            'date': end_date,
            'dispersion': disp['dispersion'],
            'signal': signal,
            'return': expected_return
        })

    df = pd.DataFrame(results)
    df['cumulative_return'] = (1 + df['return']).cumprod()
    df['portfolio_value'] = capital * df['cumulative_return']

    # Performance metrics
    total_return = df['cumulative_return'].iloc[-1] - 1
    years = (df['date'].iloc[-1] - df['date'].iloc[0]).days / 365.25
    cagr = (1 + total_return) ** (1 / years) - 1
    sharpe = df['return'].mean() / df['return'].std() * np.sqrt(252/5)

    print(f"Total Return: {total_return*100:.2f}%")
    print(f"CAGR: {cagr*100:.2f}%")
    print(f"Sharpe Ratio: {sharpe:.2f}")
    print(f"Final Portfolio Value: ${df['portfolio_value'].iloc[-1]:,.0f}")

    return df

# Run backtest
backtest_df = backtest_dispersion_strategy()

Historical Backtests (2010-2023)

Strategy Performance

Year-by-Year Breakdown

Risk Management & Hedging

1. Position Sizing

2. Stop-Losses

3. Delta Hedging Discipline

Critical: Dispersion is a volatility trade, not a directional trade. Must stay delta-neutral:

• Hedge frequency: Daily (if delta >$10k exposure per $100k portfolio)
• Hedge instrument: SPY shares, /ES futures, or index options
• Cost: 0.01-0.05% per rehedge (transaction costs + slippage)

4. Vega Risk Management

Dispersion trades are long/short vega, so vega risk needs monitoring:

# Example position
index_straddle_vega = 50  # $50 per 1% IV change
component_straddles_vega = -45  # Short vega from selling components

net_vega = index_straddle_vega + component_straddles_vega  # +$5

# If VIX rises 5%, P&L impact = net_vega * 5 = +$25
# If VIX falls 5%, P&L impact = -$25

print(f"Net Vega Exposure: ${net_vega}")
print("Risk: Small vega exposure is OK, but >$500 per contract = too much risk")

Common Mistakes to Avoid

Retail-Friendly Implementation

Recommended Brokers

Final Thoughts

Dispersion trading is how elite options desks at Citadel, Jane Street, and Susquehanna generate consistent alpha. The strategy exploits the mathematical relationship between index volatility and component volatilities, profiting when correlation breaks down.

Key Advantages:

• Market-neutral: Delta-hedged, no directional exposure
• Crisis hedge: Long dispersion makes +30-40% when markets panic
• Steady income: Short dispersion collects theta in calm markets
• Low correlation: Returns uncorrelated to stocks/bonds

Realistic Expectations:

• Dynamic strategy CAGR: 12-18%
• Sharpe ratio: 1.0-1.3
• Max drawdown: -15% to -25%
• Win rate: 60-65%

Next Steps:

1. Run the Python dispersion calculator on current market
2. Monitor CBOE DSPX index for historical context
3. Paper trade for 3 months (ThinkorSwim or TastyTrade)
4. Start with 2-5% allocation if Sharpe >0.8
5. Scale up gradually (max 10-15% of portfolio)