Mean Reversion: What It Is & How to Trade It in 2026

What Is Mean Reversion?

Mean reversion is the idea that asset prices and other financial variables tend to drift back toward a long-run average over time. When a price moves far above its historical mean, mean reversion predicts it will fall back. When it drops well below, it predicts a recovery. This behaviour creates systematic trading opportunities that quantitative firms have been exploiting for decades.

The concept is intuitive. Think about the price-to-earnings ratio of a broad equity index. It fluctuates, sometimes dramatically, but over multi-year horizons it gravitates back toward a central range. The same pattern appears in interest rate spreads, currency cross-rates, volatility indices, and commodity basis trades. Prices don't wander off to infinity or collapse to zero - they oscillate around a fair value determined by economic fundamentals.

Mathematically, a mean-reverting process ( X_t ) satisfies the condition that its expected future value, given the current state, moves toward a long-run mean ( \mu ):

[ E[X_{t+1} | X_t] = X_t + \theta(\mu - X_t) ]

where ( \theta \in (0, 1) ) controls the speed of reversion. When ( X_t > \mu ), the expected change is negative (price falls back). When ( X_t < \mu ), the expected change is positive (price rises back). This is the discrete-time version of the Ornstein-Uhlenbeck process, which we'll cover in detail later.

Mean reversion isn't a universal law. Not all financial series mean-revert, and some that do can take so long to revert that the opportunity is impractical to trade. The skill lies in identifying which series mean-revert, how fast they revert, and when the reversion signal is strong enough to act on. That's what this guide covers.

---

Mean Reversion vs Momentum

Mean reversion and momentum are opposite philosophies. Mean reversion bets that extreme moves will reverse - buy low, sell high relative to a moving average. Momentum bets that trends will continue - buy winners, sell losers. Both are well-documented in academic finance, both have produced returns historically, and both can fail spectacularly in the wrong market regime.

The tension between these two approaches is one of the most studied phenomena in quantitative finance. Eugene Fama and Kenneth French documented momentum in equity cross-sections. Andrew Lo and others documented mean reversion in individual stock returns at shorter horizons. The two effects coexist because they operate on different time scales and across different asset types.

A practical observation: many quantitative portfolios combine both. Mean reversion captures short-horizon reversals while momentum captures medium-horizon trends. Because they tend to perform well in opposite market conditions, the combination can produce smoother returns than either approach alone. Understanding both strategy families is essential for any serious quantitative trader.

---

How to Test if a Series Is Mean-Reverting

Before trading mean reversion, you need statistical evidence that the series actually mean-reverts. Three tests form the standard toolkit: the augmented Dickey-Fuller (ADF) test for stationarity, the Hurst exponent for long-range dependence, and the half-life of mean reversion for speed estimation. Here's how each works, with Python code you can run directly.

The Augmented Dickey-Fuller Test

The ADF test checks whether a time series has a unit root. If it does, the series follows a random walk and doesn't mean-revert. If the unit root is rejected, the series is stationary and mean-reverting. This is the most widely used test in quantitative finance for this purpose.

The null hypothesis is that the series has a unit root (no mean reversion). You want to reject this null - a sufficiently negative test statistic (or a p-value below 0.05) indicates mean reversion.

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


def test_mean_reversion_adf(
    series: pd.Series,
    significance: float = 0.05,
) -> dict:
    """
    Test whether a series is mean-reverting using the ADF test.

    Parameters
    ----------
    series : pd.Series
        The price or spread series to test.
    significance : float
        Significance level for rejection (default 0.05).

    Returns
    -------
    dict with test statistic, p-value, and conclusion.
    """
    result = adfuller(series.dropna(), autolag="AIC")
    adf_stat, p_value, used_lag, n_obs, critical_values, _ = result

    return {
        "adf_statistic": adf_stat,
        "p_value": p_value,
        "used_lag": used_lag,
        "critical_values": critical_values,
        "is_mean_reverting": p_value < significance,
    }


# Example: test a spread for mean reversion
np.random.seed(42)
n = 500

# Simulated mean-reverting spread (OU process)
theta = 0.05  # speed of reversion
mu = 0.0      # long-run mean
sigma = 0.3   # volatility

spread = np.zeros(n)
for t in range(1, n):
    spread[t] = (
        spread[t - 1]
        + theta * (mu - spread[t - 1])
        + sigma * np.random.normal()
    )

series = pd.Series(spread, name="Spread")
result = test_mean_reversion_adf(series)

print(f"ADF statistic: {result['adf_statistic']:.4f}")
print(f"P-value: {result['p_value']:.6f}")
print(f"Mean-reverting at 5%: {result['is_mean_reverting']}")

A critical point: the ADF test tells you whether a series mean-reverts, not how fast. A series might be stationary but revert so slowly that the opportunity isn't tradeable. For speed, you need the half-life.

The Hurst Exponent

The Hurst exponent ( H ) classifies time series behaviour on a scale from 0 to 1. A value of ( H = 0.5 ) indicates a random walk. ( H < 0.5 ) indicates mean reversion - the lower the value, the stronger the reversion. ( H > 0.5 ) indicates trending (momentum) behaviour.

import numpy as np
import pandas as pd


def hurst_exponent(series: pd.Series, max_lag: int = 100) -> float:
    """
    Estimate the Hurst exponent using the rescaled range (R/S) method.

    H < 0.5: mean-reverting
    H = 0.5: random walk
    H > 0.5: trending
    """
    series = series.dropna().values
    lags = range(2, max_lag)
    tau = []

    for lag in lags:
        subseries = [series[i:i + lag] for i in range(0, len(series) - lag)]
        rs_values = []

        for sub in subseries:
            mean_sub = np.mean(sub)
            deviations = np.cumsum(sub - mean_sub)
            r = np.max(deviations) - np.min(deviations)
            s = np.std(sub, ddof=1)
            if s > 0:
                rs_values.append(r / s)

        if rs_values:
            tau.append(np.mean(rs_values))

    log_lags = np.log(list(lags[: len(tau)]))
    log_tau = np.log(tau)

    # Linear regression of log(R/S) on log(lag)
    coeffs = np.polyfit(log_lags, log_tau, 1)
    return coeffs[0]


# Test on our simulated mean-reverting series
h = hurst_exponent(series)
print(f"Hurst exponent: {h:.4f}")
if h < 0.5:
    print("Series is mean-reverting")
elif h > 0.5:
    print("Series is trending")
else:
    print("Series is a random walk")

The Hurst exponent is useful as a quick screening tool. If you're scanning hundreds of spreads for mean-reversion candidates, computing ( H ) for each is fast and gives an immediate ranking. Pairs with the lowest Hurst exponents are the strongest mean-reversion candidates.

Half-Life of Mean Reversion

The half-life tells you how many periods it takes, on average, for a deviation from the mean to decay by half. It's estimated by running an OLS regression of the change in the spread on its lagged level:

[ \Delta Z_t = \lambda Z_{t-1} + \epsilon_t ]

If ( \lambda < 0 ), the series is mean-reverting, and the half-life is:

[ t_{1/2} = -\frac{\ln 2}{\ln(1 + \lambda)} \approx -\frac{\ln 2}{\lambda} ]

import numpy as np
import pandas as pd
import statsmodels.api as sm


def half_life(series: pd.Series) -> float:
    """
    Estimate the half-life of mean reversion from a spread series.
    Returns the number of periods for a deviation to decay by half.
    """
    lagged = series.shift(1)
    delta = series - lagged
    lagged = sm.add_constant(lagged)

    # Drop NaN from the shift
    mask = delta.notna() & lagged.iloc[:, 1].notna()
    model = sm.OLS(delta[mask], lagged[mask]).fit()

    lambda_coeff = model.params.iloc[1]

    if lambda_coeff >= 0:
        return float("inf")  # not mean-reverting

    return -np.log(2) / lambda_coeff


hl = half_life(series)
print(f"Half-life of mean reversion: {hl:.1f} periods")

The half-life is arguably the most important number for a mean-reversion trader. If the half-life is 5 days, you can expect deviations to correct within a couple of weeks - very tradeable. If it's 200 days, the reversion is real but far too slow for most strategies. As a rule of thumb, half-lives between 5 and 60 days are the sweet spot for daily trading strategies.

---

Common Mean Reversion Strategies

Mean reversion strategies share a common structure: identify a variable that has moved far from its average, take a position betting on a return to that average, and exit when reversion occurs. The differences lie in how you define "far from average" and which variables you track. Here are the approaches used most widely in 2026.

Bollinger Band Reversion

Bollinger Bands plot a moving average with upper and lower bands at ( \pm k ) standard deviations (typically ( k = 2 )). A mean-reversion signal triggers when the price touches or crosses the outer band and then turns back. Traders go long when the price hits the lower band (oversold) and short when it hits the upper band (overbought), targeting a return to the moving average.

This works best on range-bound instruments. In trending markets, prices can "walk along the band" for extended periods, making the strategy unprofitable. Combining Bollinger Bands with a stationarity filter (only trade when the ADF test confirms mean reversion) significantly improves results.

RSI Mean Reversion

The Relative Strength Index (RSI) measures recent gains against recent losses on a 0-100 scale. Traditional thresholds treat RSI below 30 as oversold and above 70 as overbought. A mean-reversion trader buys on low RSI and sells on high RSI, expecting the price to snap back.

The RSI approach works reasonably well on large-cap equities and equity indices at the daily frequency. Larry Connors popularised a variant using a 2-period RSI with more extreme thresholds (below 10 to buy, above 90 to sell), which has shown stronger historical returns than the standard 14-period version.

Z-Score of the Spread

For pairs trading and relative value strategies, the z-score of the spread is the standard approach. Compute the spread between two cointegrated assets, normalise it by its rolling mean and standard deviation, and trade when the z-score exceeds a threshold (typically ( \pm 2 )).

This is more principled than single-asset indicators because it's grounded in a statistical relationship. The z-score directly measures how many standard deviations the spread has moved from its mean, giving a natural probabilistic interpretation.

Pairs Trading

Pairs trading is the most well-known mean-reversion strategy. You identify two assets with a stable long-run relationship, go long the underperformer and short the outperformer when the spread widens, and wait for convergence. The key requirement is cointegration - not mere correlation - between the two assets.

ETF Arbitrage

ETFs can temporarily deviate from their net asset value (NAV), creating mean-reversion opportunities. If an ETF trades at a premium to its underlying basket, you can short the ETF and buy the constituents (or vice versa for a discount). Authorised participants do this systematically, but the opportunity also exists for quantitative traders at the intraday level.

---

Building a Mean Reversion Strategy in Python

Here's a complete implementation of a z-score-based pairs trading strategy. This brings together the statistical tests from earlier sections with actual trading logic you can adapt for your own use.

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


class MeanReversionPairsStrategy:
    """
    Z-score-based pairs trading strategy with cointegration checks.
    """

    def __init__(
        self,
        lookback: int = 60,
        entry_z: float = 2.0,
        exit_z: float = 0.0,
        stop_z: float = 4.0,
        coint_threshold: float = 0.05,
    ):
        self.lookback = lookback
        self.entry_z = entry_z
        self.exit_z = exit_z
        self.stop_z = stop_z
        self.coint_threshold = coint_threshold

    def estimate_hedge_ratio(
        self, y: pd.Series, x: pd.Series
    ) -> float:
        x_const = sm.add_constant(x)
        model = sm.OLS(y, x_const).fit()
        return model.params.iloc[1]

    def compute_spread(
        self, y: pd.Series, x: pd.Series, hedge_ratio: float
    ) -> pd.Series:
        return y - hedge_ratio * x

    def compute_z_score(self, spread: pd.Series) -> pd.Series:
        mean = spread.rolling(window=self.lookback).mean()
        std = spread.rolling(window=self.lookback).std()
        return (spread - mean) / std

    def check_cointegration(
        self, spread: pd.Series
    ) -> bool:
        result = adfuller(spread.dropna(), autolag="AIC")
        return result[1] < self.coint_threshold

    def generate_signals(
        self, z_score: pd.Series
    ) -> pd.Series:
        position = pd.Series(0.0, index=z_score.index)

        for i in range(1, len(z_score)):
            z = z_score.iloc[i]
            prev = position.iloc[i - 1]

            if np.isnan(z):
                position.iloc[i] = 0.0
                continue

            if prev == 0:
                if z < -self.entry_z:
                    position.iloc[i] = 1.0
                elif z > self.entry_z:
                    position.iloc[i] = -1.0
            elif prev > 0:
                if z > -self.exit_z or z < -self.stop_z:
                    position.iloc[i] = 0.0
                else:
                    position.iloc[i] = prev
            elif prev < 0:
                if z < self.exit_z or z > self.stop_z:
                    position.iloc[i] = 0.0
                else:
                    position.iloc[i] = prev

        return position

    def backtest(
        self,
        y: pd.Series,
        x: pd.Series,
    ) -> pd.DataFrame:
        hedge_ratio = self.estimate_hedge_ratio(y, x)
        spread = self.compute_spread(y, x, hedge_ratio)

        if not self.check_cointegration(spread):
            print("Warning: spread fails cointegration test")

        z_score = self.compute_z_score(spread)
        position = self.generate_signals(z_score)

        spread_returns = spread.diff()
        pnl = position.shift(1) * spread_returns
        cumulative_pnl = pnl.cumsum()

        return pd.DataFrame({
            "spread": spread,
            "z_score": z_score,
            "position": position,
            "pnl": pnl,
            "cumulative_pnl": cumulative_pnl,
            "hedge_ratio": hedge_ratio,
        })


# --- Example: simulated cointegrated pair ---
np.random.seed(42)
n = 1000

common_factor = np.cumsum(np.random.normal(0, 1, n)) + 100
stock_y = common_factor + np.random.normal(0, 1.5, n) + 50
stock_x = 0.8 * common_factor + np.random.normal(0, 1.0, n) + 30

y = pd.Series(stock_y, name="Stock_Y")
x = pd.Series(stock_x, name="Stock_X")

strategy = MeanReversionPairsStrategy(
    lookback=60, entry_z=2.0, exit_z=0.0, stop_z=4.0
)
results = strategy.backtest(y, x)

total_pnl = results["pnl"].sum()
n_trades = (results["position"].diff().abs() > 0).sum()
win_rate = (
    results.loc[results["pnl"] != 0, "pnl"] > 0
).mean()

print(f"Hedge ratio: {results['hedge_ratio'].iloc[0]:.4f}")
print(f"Total PnL: {total_pnl:.2f}")
print(f"Number of trades: {n_trades}")
print(f"Win rate: {win_rate:.1%}")
print(f"Sharpe (daily): {results['pnl'].mean() / results['pnl'].std():.3f}")

This is a teaching implementation. A production system would add transaction cost modelling, dynamic hedge ratio estimation (using a Kalman filter or rolling OLS), position sizing based on spread volatility, and real-time cointegration monitoring that scales down exposure when the statistical relationship weakens. The fundamentals of algorithmic execution apply directly when moving from backtest to live trading.

---

Mean Reversion in Different Asset Classes

Mean reversion exists across all major asset classes, but the strength and speed vary considerably. Knowing where mean reversion works best - and where it doesn't - is critical for allocating research time and trading capital.

Equities

Individual stock prices are generally poor candidates for single-asset mean reversion. Most stocks follow approximate random walks, and price drops often reflect genuine fundamental deterioration rather than temporary dislocations. The exception is at the portfolio level: equity pairs and baskets constructed from cointegrated stocks can show strong mean reversion. Sector-neutral strategies that go long underperformers and short outperformers within the same industry have a long track record of profitability, though returns have compressed as the strategy has become more crowded.

Short-horizon equity mean reversion (1-5 day reversals) remains one of the most consistent quantitative strategies, particularly in mid-cap stocks where institutional liquidity effects create temporary mispricings.

Foreign Exchange

FX is arguably the best asset class for mean reversion. Currency pairs are bounded by purchasing power parity and interest rate differentials over long horizons, and crosses between developed-market currencies show strong mean-reverting behaviour at the weekly to monthly frequency. The carry trade - buying high-yield currencies and selling low-yield currencies - is itself a form of mean reversion, betting that the spot rate won't move enough to offset the interest rate differential.

Cross-rates like EUR/GBP or AUD/NZD, which pair economically similar countries, tend to have the shortest half-lives and the strongest mean-reversion properties.

Commodities

Commodity prices mean-revert over long horizons because production responds to price. When oil prices spike, drilling activity increases, supply grows, and prices eventually fall back. When prices collapse, producers shut down marginal wells, supply contracts, and prices recover. This supply-response mechanism creates genuine economic mean reversion with half-lives measured in months to years.

Commodity spreads - calendar spreads, crack spreads, and inter-commodity spreads - often mean-revert much faster than outright prices, making them more suitable for systematic trading.

Fixed Income

Interest rate spreads are among the cleanest mean-reverting series in finance. The spread between two government bond yields of similar maturity (say, 5-year UK gilts vs 5-year German bunds) fluctuates but gravitates toward a level determined by relative credit quality, inflation expectations, and monetary policy divergence. Yield curve trades (steepeners and flatteners) and basis trades between cash bonds and futures are classic fixed income mean-reversion strategies.

Credit spreads also mean-revert, though with significant tail risk. Investment-grade credit spreads tend to widen during stress and tighten during calm periods, cycling around a long-run average. The risk is that "this time it's different" - sometimes widening spreads reflect genuine default risk rather than temporary fear.

---

Risk Management for Mean Reversion

Mean reversion strategies have a characteristic risk profile: frequent small profits and occasional large losses. Managing those occasional losses is the difference between a profitable strategy and a blown-up account. Here are the key risk management principles specific to mean-reversion trading.

Stop Losses Are Not Optional

The defining risk of a mean-reversion strategy is that the reversion never comes. A spread that you expect to narrow could instead widen permanently because the underlying economic relationship has changed. Without a stop loss, you keep adding to a losing position, convinced that reversion is "just around the corner." This is how most mean-reversion blowups happen.

Set stop losses based on statistical thresholds. If your entry is at a z-score of 2, a stop at 4 means you're cutting the trade if the spread reaches a level that would occur less than 0.01% of the time under the historical distribution. If the spread actually reaches that level, something fundamental has likely changed.

Position Sizing

Size positions based on the volatility of the spread, not the volatility of the individual assets. A pair where each leg moves 2% per day but the spread moves only 0.3% per day should be sized according to the 0.3% figure. Many traders use a fixed-risk approach: size the position so that a 1-standard-deviation adverse move in the spread represents a fixed percentage of portfolio equity.

Regime Detection

Mean reversion strategies fail during regime changes - when a market transitions from range-bound to trending, or when a long-standing economic relationship breaks. Monitoring for regime changes is essential. Practical approaches include tracking the rolling ADF test p-value on the spread, monitoring the half-life for drift, and watching the Hurst exponent for shifts above 0.5.

If your spread's ADF p-value rises above 0.10, it's time to reduce exposure. If it rises above 0.20, consider exiting entirely. Re-enter only when statistical evidence for mean reversion re-establishes.

When Mean Reversion Fails

Mean reversion fails in three main scenarios. First, structural breaks: a merger, regulatory change, or business model shift permanently alters the relationship between two assets. Second, crowding: too many traders pile into the same mean-reversion trade, and when they all try to exit simultaneously, the spread blows out. Third, liquidity crises: during market stress, correlations spike and spreads that "should" converge instead diverge further as forced selling overrides fundamental relationships.

The 2007-2008 quant crisis is the textbook example. Quantitative equity market-neutral funds - most of which relied on mean-reversion signals - experienced massive losses when crowded positions unwound simultaneously. The statistical relationships that underpinned the strategies were real, but the crowding risk wasn't properly accounted for.

---

The Ornstein-Uhlenbeck Process

The Ornstein-Uhlenbeck (OU) process is the continuous-time mathematical model that describes mean-reverting behaviour. It's the standard model used by quantitative analysts and researchers to represent spreads, interest rates, volatility, and any other financial variable that reverts to a long-run level. Understanding it gives you a rigorous framework for thinking about mean reversion and estimating its parameters.

The OU process is defined by the stochastic differential equation:

[ dX_t = \theta(\mu - X_t),dt + \sigma,dW_t ]

where:

• ( X_t ) is the value of the process at time ( t )
• ( \mu ) is the long-run mean
• ( \theta > 0 ) is the speed of mean reversion (higher values mean faster reversion)
• ( \sigma ) is the volatility parameter
• ( W_t ) is a standard Brownian motion (Wiener process)

The three parameters have direct trading interpretations. ( \mu ) tells you where the spread is heading. ( \theta ) tells you how quickly it gets there - the half-life is ( \ln 2 / \theta ). And ( \sigma ) tells you how much noise surrounds the reversion path. A "good" mean-reversion opportunity has a high ( \theta ) (fast reversion) and a moderate ( \sigma ) (enough volatility to create entry points but not so much that stop losses are constantly triggered).

Parameter Estimation

You can estimate the OU parameters from discrete observations using maximum likelihood or the simpler method of moments (which amounts to an OLS regression). Here's a Python implementation:

import numpy as np
import pandas as pd
import statsmodels.api as sm


def estimate_ou_parameters(
    series: pd.Series,
    dt: float = 1.0,
) -> dict:
    """
    Estimate Ornstein-Uhlenbeck parameters from a discrete time series.

    Parameters
    ----------
    series : pd.Series
        Observed values of the mean-reverting process.
    dt : float
        Time step between observations (1.0 for daily data).

    Returns
    -------
    dict with theta (speed), mu (long-run mean), sigma (volatility),
    and half_life.
    """
    x = series.values[:-1]
    y = series.values[1:]

    x_const = sm.add_constant(x)
    model = sm.OLS(y, x_const).fit()

    a = model.params[0]  # intercept
    b = model.params[1]  # slope on lagged value

    theta = -np.log(b) / dt
    mu = a / (1 - b)
    sigma_eq = model.resid.std()
    sigma = sigma_eq * np.sqrt(
        2 * theta / (1 - np.exp(-2 * theta * dt))
    )

    half_life = np.log(2) / theta

    return {
        "theta": theta,
        "mu": mu,
        "sigma": sigma,
        "half_life": half_life,
        "r_squared": model.rsquared,
    }


# Simulate an OU process
np.random.seed(42)
n = 1000
dt = 1.0
theta_true = 0.05
mu_true = 100.0
sigma_true = 2.0

x = np.zeros(n)
x[0] = 100.0
for t in range(1, n):
    x[t] = (
        x[t - 1]
        + theta_true * (mu_true - x[t - 1]) * dt
        + sigma_true * np.sqrt(dt) * np.random.normal()
    )

series = pd.Series(x, name="OU_Process")
params = estimate_ou_parameters(series, dt=1.0)

print("Estimated OU parameters:")
print(f"  theta (speed):    {params['theta']:.4f} (true: {theta_true})")
print(f"  mu (mean):        {params['mu']:.2f} (true: {mu_true})")
print(f"  sigma (vol):      {params['sigma']:.2f} (true: {sigma_true})")
print(f"  half-life:        {params['half_life']:.1f} days")
print(f"  R-squared:        {params['r_squared']:.4f}")

How Quants Use the OU Model

In practice, quantitative firms fit the OU model to spreads between cointegrated assets, then use the estimated parameters to make trading decisions. The long-run mean ( \mu ) defines the target for the spread. The half-life determines the expected holding period. The volatility ( \sigma ) combined with ( \theta ) determines the stationary distribution of the spread, which is normal with mean ( \mu ) and variance ( \sigma^2 / (2\theta) ).

Entry and exit signals are then calibrated using this stationary distribution. If the current spread is 2 standard deviations from ( \mu ) (using the stationary standard deviation), there's roughly a 95% probability that it will eventually return. The OU model gives this claim a rigorous mathematical foundation rather than relying on ad hoc rules.

Some firms go further and use the OU model for optimal execution. Given a mean-reverting signal, the optimal strategy isn't necessarily to enter immediately at full size. The expected path of the OU process can be used to determine when to scale in and when to take profit, maximising expected return per unit of risk.

For those looking to go deeper, the OU model connects directly to stochastic calculus and the broader class of diffusion processes used throughout quantitative finance.

---

Frequently Asked Questions

What is mean reversion in simple terms?

Mean reversion is the tendency for prices to move back toward their historical average after moving too far in one direction. If a stock's price-to-earnings ratio is usually around 15 and it spikes to 25, mean reversion predicts it will eventually fall back toward 15. It doesn't guarantee this happens quickly or at all - economic conditions can change - but the statistical tendency is well-documented across many financial variables. Traders exploit this by buying assets that have fallen below their average and selling those that have risen above it.

Does mean reversion actually work in stock markets?

Mean reversion works well for spreads, ratios, and relative values - less so for individual stock prices in isolation. A single stock can fall 80% and never recover because the business genuinely deteriorated. But the spread between two cointegrated stocks, or the price-to-earnings ratio of an equity index, shows strong mean-reverting behaviour. The key is choosing the right variable. Statistical tests like the ADF test and Hurst exponent can confirm whether a specific series mean-reverts before you commit capital.

How do you calculate the half-life of mean reversion?

Run an OLS regression of the change in the series on its lagged level: ( \Delta X_t = \lambda X_{t-1} + \epsilon_t ). If ( \lambda ) is negative, the series mean-reverts, and the half-life is ( -\ln(2) / \lambda ). For example, if ( \lambda = -0.05 ), the half-life is about 14 periods. This tells you that a deviation from the mean decays by half every 14 periods on average. Half-lives between 5 and 60 days are typically the most tradeable for daily strategies.

What is the Ornstein-Uhlenbeck process?

The Ornstein-Uhlenbeck process is a continuous-time stochastic process that models mean reversion mathematically. It's defined by ( dX_t = \theta(\mu - X_t),dt + \sigma,dW_t ), where ( \theta ) controls how fast the process reverts to the mean ( \mu ), and ( \sigma ) controls the volatility. It's the standard model in quantitative finance for describing interest rates, volatility, and spreads that fluctuate around a central value. Quant traders estimate its parameters from data and use them to calibrate entry and exit signals for mean-reversion strategies.

What is the difference between mean reversion and pairs trading?

Mean reversion is the broader concept - the statistical tendency for a variable to return to its average. Pairs trading is one specific strategy that exploits mean reversion. In pairs trading, you find two cointegrated assets, compute the spread between them, and trade the mean reversion of that spread. But mean reversion also applies to single-asset indicators (like RSI or Bollinger Bands), commodity basis trades, yield curve trades, and many other contexts. Pairs trading is probably the most popular application of mean reversion in quantitative finance, but it's not the only one.

What are the biggest risks of mean reversion strategies?

The primary risk is that the mean shifts. A spread you expect to narrow could widen permanently because the underlying relationship has broken - a company changed its business model, a regulation shifted, or a market regime changed. Crowding is another major risk: if too many traders exploit the same mean-reversion signal, exits become correlated and losses amplify. Liquidity risk matters too - mean-reversion trades often involve less liquid instruments where spreads widen under stress. Finally, mean-reversion strategies typically have a negative skew risk profile (many small gains, occasional large losses), which means that proper risk management with strict stop losses and position sizing is essential to long-term survival.