Statistical Arbitrage: Quantitative Mean Reversion

🚨 This Isn't "Buy Dips" Hope Trading

Statistical arbitrage requires rigorous mathematical validation. You can't just eyeball two charts and assume they'll converge. You need cointegration tests, z-score models, and proper risk management—because spreads can diverge further before they converge.

Without quantitative validation? You're gambling, not arbitraging.

The Most Dangerous Misconception in Pairs Trading

Retail traders love to find "correlated pairs" and trade the divergence. SPY and QQQ move together, right? Tesla and Lucid? Bitcoin and Ethereum?

Here's the trap: Correlation does not guarantee mean reversion.

Two assets can be highly correlated yet drift apart permanently. Why? Because correlation measures direction, not equilibrium.

The Augmented Dickey-Fuller Test

To validate cointegration, you need to test whether the spread (or ratio) is stationary—meaning it has a constant mean it reverts to.

The standard test: Augmented Dickey-Fuller (ADF) test.

Interpreting ADF Test Results

The ADF test outputs a p-value that tells you the probability that the spread is non-stationary (random walk).

Calculating the Hedge Ratio

Before running the ADF test, you need to determine the hedge ratio (β)—the optimal proportion to balance the two assets in the pair.

Method: Run an Ordinary Least Squares (OLS) regression:

Asset A = β × Asset B + ε

β (beta) = hedge ratio

Example: KO vs PEP

Step 1: Collect Historical Prices
KO (Coca-Cola): Last 252 days of closing prices
PEP (PepsiCo): Last 252 days of closing prices

Step 2: Run OLS Regression (KO = β × PEP)
Using Python statsmodels or Excel LINEST function
Result: β = 1.12

Interpretation:
For every $1 of PEP, you need $1.12 of KO to create a hedged pair.

Step 3: Calculate Spread
Spread = KO - (1.12 × PEP)

Example values:
- KO = $60.50
- PEP = $180.20
- Spread = $60.50 - (1.12 × $180.20) = $60.50 - $201.82 = -$141.32

Step 4: Run ADF Test on Spread
ADF Test Result: p-value = 0.018 ✅
Interpretation: Spread is stationary (cointegrated at 98% confidence)
Conclusion: KO/PEP is a tradeable pair
      

Real Example: SPY/IWM Cointegration Test

Z-Score: The Trading Signal

Once you've confirmed cointegration (ADF p < 0.05), you need a trading signal to tell you WHEN to enter and exit. That signal is the z-score.

Z-Score Trading Frameworks

Half-Life: How Long Until Reversion?

The half-life tells you how many periods it takes for the spread to revert halfway back to the mean. This informs your holding period.

How Much to Allocate Per Trade

Statistical arbitrage is NOT "set it and forget it." Spreads can widen before they converge (drawdowns), and some pairs decointegrate over time.

Kelly Criterion for Stat Arb

Use a modified Kelly approach:

f* = (p × b - q) / b

Where:

• p = win rate (historical % of profitable mean reversions)
• q = loss rate (1 - p)
• b = average win / average loss
• f* = optimal fraction of capital to risk

Portfolio of Pairs: Diversification

Don't run just one pair. Build a portfolio of 5-10 cointegrated pairs across different sectors to reduce idiosyncratic risk.

Regime Changes & Decointegration

Statistical arbitrage works—until it doesn't. Pairs can decointegrate due to:

• Corporate Actions: Mergers, spinoffs, dividend changes
• Structural Shifts: One company changes business model
• Macro Regime Change: Interest rate shocks, sector rotation
• Liquidity Drying Up: Can't potential exit the position without slippage

Stop Loss Rules for Stat Arb

• Z-Score Stop: Exit if |Z| > 3.5 (spread widening, not reverting)
• Time Stop: Exit if position is open > 2× half-life (model failing)
• Dollar Stop: Exit if drawdown exceeds 50% of expected profit
• Correlation Breakdown: Exit if ADF p-value goes above 0.10 (losing cointegration)

Building Your Stat Arb System

Step-by-step process for running statistical arbitrage:

High-Frequency Mean Reversion (For Active Traders)

Most stat arb is swing trading (holding 5-30 days), but cointegration also works on intraday timeframes—if you have the infrastructure.

Requirements for Intraday Stat Arb

• Low Latency Execution: Sub-second fills required (DMA or sponsored access)
• High-Liquidity Pairs: SPY/IWM, QQQ/DIA, sector ETFs only
• Tight Spreads: Commission + slippage must be <0.02% per trade
• Automated System: Manual trading too slow for 5-minute half-lives

Building a Diversified Stat Arb Book

Single-pair trading is risky (decointegration can wipe you out). Professional stat arb traders run portfolios of 10-30 pairs simultaneously.

Example Portfolio Allocation

Rebalancing Your Stat Arb Portfolio

Building Your Stat Arb System from Scratch

Here's a practical Python implementation for testing and trading pairs:

import pandas as pd
import numpy as np
from statsmodels.tsa.stattools import adfuller
from statsmodels.api import OLS

# Example: Test KO vs PEP cointegration
ko = pd.read_csv('KO_daily.csv')['Close']
pep = pd.read_csv('PEP_daily.csv')['Close']

# Calculate hedge ratio using OLS regression
model = OLS(ko, pep).fit()
beta = model.params[0]
print(f"Hedge Ratio (β): {beta:.4f}")

# Calculate spread
spread = ko - (beta * pep)

# Run ADF test on spread
adf_result = adfuller(spread)
p_value = adf_result[1]

if p_value < 0.05:
    print(f"✅ COINTEGRATED! (p-value: {p_value:.4f})")
else:
    print(f"❌ NOT cointegrated (p-value: {p_value:.4f})")

# Calculate half-life
def calculate_half_life(spread):
    spread_lag = spread.shift(1)
    spread_diff = spread - spread_lag
    model = OLS(spread_diff[1:], spread_lag[1:]).fit()
    theta = model.params[0]
    half_life = -np.log(2) / np.log(1 + theta)
    return half_life

half_life = calculate_half_life(spread)
print(f"Half-Life: {half_life:.1f} days")

# Calculate rolling z-score
lookback = 60  # 60-day rolling window

spread_mean = spread.rolling(window=lookback).mean()
spread_std = spread.rolling(window=lookback).std()
z_score = (spread - spread_mean) / spread_std

# Entry/exit signals
potential entry_threshold = 2.0
potential exit_threshold = 0.0
stop_threshold = 3.5

# Long spread signal (buy asset A, sell asset B)
long_potential entry = z_score < -potential entry_threshold
long_potential exit = z_score > -potential exit_threshold

# Short spread signal (sell asset A, buy asset B)
short_potential entry = z_score > potential entry_threshold
short_potential exit = z_score < potential exit_threshold

# Stop loss
stop_loss = (z_score > stop_threshold) | (z_score < -stop_threshold)

print(f"Current Z-Score: {z_score.iloc[-1]:.2f}")
if z_score.iloc[-1] > potential entry_threshold:
    print("🔴 SHORT SPREAD (sell KO, buy PEP)")
elif z_score.iloc[-1] < -potential entry_threshold:
    print("🟢 LONG SPREAD (buy KO, sell PEP)")
else:
    print("⚪ NO TRADE (waiting for signal)")

# Simple backtest
position = 0  # 0 = no position, 1 = long spread, -1 = short spread
trades = []
pnl = []

for i in range(lookback, len(z_score)):
    z = z_score.iloc[i]

    # Entry logic
    if position == 0:
        if z < -potential entry_threshold:
            position = 1  # Long spread
            potential entry_price = spread.iloc[i]
        elif z > potential entry_threshold:
            position = -1  # Short spread
            potential entry_price = spread.iloc[i]

    # Exit logic
    elif position == 1:  # In long spread
        if z > -potential exit_threshold or z < -stop_threshold:
            potential exit_price = spread.iloc[i]
            profit = potential exit_price - potential entry_price
            trades.append(profit)
            position = 0

    elif position == -1:  # In short spread
        if z < potential exit_threshold or z > stop_threshold:
            potential exit_price = spread.iloc[i]
            profit = potential entry_price - potential exit_price
            trades.append(profit)
            position = 0

# Calculate statistics
win_rate = len([t for t in trades if t > 0]) / len(trades)
avg_win = np.mean([t for t in trades if t > 0])
avg_loss = np.mean([t for t in trades if t < 0])
profit_factor = abs(sum([t for t in trades if t > 0])) / abs(sum([t for t in trades if t < 0]))

print(f"Total Trades: {len(trades)}")
print(f"Win Rate: {win_rate:.1%}")
print(f"Avg Win: ${avg_win:.2f}")
print(f"Avg Loss: ${avg_loss:.2f}")
print(f"Profit Factor: {profit_factor:.2f}")
print(f"Total PnL: ${sum(trades):.2f}")

Statistical arbitrage is a quantitative edge—but it requires discipline. If you execute this correctly, you're trading with mathematical precision instead of hope.

Related Lessons

• #64: Macro Regime Framework — How regime changes affect stat arb
• #66: Quantitative Strategy Design — Backtest stat arb strategies
• #67: Machine Learning in Trading — ML for pair selection