This post presents a framework for answering that question empirically. We measure whether an alpha's recent performance metrics contain information about its near-term future, including whether degraded performance predicts continued degradation. We demonstrate on FX alphas (30-minute bars) and then generalise across asset classes.

Step 1: Define the Question

Consider the 5-bar mean-reversion Z-score on FX. Its rolling Sharpe over the last 60 bars currently reads 2.1. The question: does this value contain information about the alpha's PnL over the next 60 bars?

If yes, dynamic allocation is justified. If no, static weights are optimal.

Step 2: Two Measurement Tools

Tool 1: Rank IC (Spearman Correlation)

Rank all time-points of the predictor (e.g. rolling Sharpe). Rank all time-points of the outcome (forward PnL). The Spearman correlation between these two rank vectors is the Rank IC. It ranges from −1 to +1; zero indicates no monotonic relationship.

Interpreting small ICs. A rank IC of 0.05 implies approximately 52–53% directional accuracy on any individual observation. This appears negligible, but the fundamental law of active management (Grinold, 1989) shows that portfolio-level information ratio scales as IR = IC × √N, where N is the number of independent bets. Applying IC = 0.05 across 60 alpha-asset pairs with weekly rebalancing yields IR = 0.05 × √(60 × 52) ≈ 2.8. This is a substantial portfolio-level edge.

For reference, most systematic funds operate on signal ICs of 0.02–0.10. The value lies not in single-observation accuracy but in breadth of application and frequency of rebalancing.

Limitation: captures only monotonic (rank-order) dependence.

Tool 2: Mutual Information (MI)

If both very high and very low rolling volatility predict poor forward performance (a U-shaped relationship), Rank IC will read near zero. Mutual Information captures any statistical dependence between predictor and outcome, including nonlinear and non-monotonic patterns. MI is measured in nats; MI = 0 indicates statistical independence.

In practice, compute MI alongside Rank IC. If both are elevated, the relationship is monotonic. If MI is high but Rank IC is near zero, nonlinear structure is present.

Step 3: Demonstration on FX (30-Minute Bars)

We apply both tools to 12 alphas on G7 FX (6 pairs, 30M bars, 2022–2026). For each alpha, 6 rolling metrics (Sharpe, Mean, Hit Rate, Volatility, Max Drawdown, Autocorrelation) are computed with 4 lookback windows (20, 60, 120, 252 bars) and tested against 4 forward horizons (20, 60, 120, 252 bars).

Predictability Results: Rank IC and Mutual Information

Left panel: mean |Rank IC| (monotonic predictability). Right panel: mean MI in nats (any dependence, including nonlinear). Key observations:

• Rolling mean return is the strongest predictor (highest Rank IC and highest MI). Performance momentum is real: recently profitable alphas tend to remain profitable.

• Longer lookbacks are more informative. The 252-bar window consistently outperforms the 20-bar window in both Rank IC and MI.

• Volatility is inversely predictive. Elevated recent PnL volatility forecasts deteriorating forward performance. MI confirms this is predominantly a monotonic effect (high vol → worse outcomes), not a U-shaped one.

• MI and Rank IC largely agree. The predictive relationships are predominantly monotonic. Nonlinear effects exist but are not the primary source of predictability in this dataset.

Does Degraded Performance Predict Continued Degradation?

We can split the Rank IC analysis by conditioning on the sign of recent performance. This separates the question into two halves:

• When rolling mean > 0 (alpha is currently profitable): forward PnL is more likely positive than negative. Directional accuracy: 54–58%. Interpretation: recent winners tend to keep winning.

• When rolling mean < 0 (alpha is currently in drawdown): forward PnL is more likely negative than positive. Directional accuracy: 52–56%. Interpretation: recent losers tend to keep losing.

Both sides are statistically significant. The positive-conditioning case is slightly stronger (persistence of winning is marginally more predictable than persistence of losing), but the key result is that degradation is predictable. An alpha whose rolling Sharpe has turned negative over 252 bars is statistically more likely to remain negative over the next 120 bars than to recover.

This makes the framework both an allocation tool (size winners) and a risk management tool (reduce exposure to alphas entering drawdown regimes).

Step 4: Cross-Asset Generalisation

Extending the analysis to all 5 asset classes (Equity Futures, Bonds, Commodities, FX, Crypto) confirms the FX findings:

• FX exhibits the strongest predictability, consistent with persistent microstructure regimes.

• Equity index futures are the least predictable, consistent with efficient pricing at all timescales.

• Optimal forward horizon is 60–120 bars (1–2.5 trading days on 30M data).

• Matched lookback-horizon pairs outperform mismatched ones. A 120-bar lookback forecasts 120-bar performance more effectively than a 20-bar lookback does.

• 30–50% of tests reach statistical significance at p < 0.05, compared to the 5% expected under the null hypothesis.

Signed Rank IC by alpha and asset class. Blue indicates performance momentum (positive persistence); red indicates performance mean-reversion. The majority of cells are positive: performance momentum is the dominant regime. Mean-reversion alphas exhibit the strongest persistence; trend-following alphas are more regime-dependent.

Practical Implementation

• 1. Metric selection. Use rolling mean PnL as the primary predictor. It is the most robust across asset classes and timescales.

• 2. Lookback-horizon matching. Set the lookback window equal to the rebalancing horizon. Monthly rebalancing: ~252-bar lookback on 30M (or ~20 days on daily). Weekly: ~60 bars.

• 3. Tilt weights, do not switch alphas on/off. At IC ≈ 0.10 (approximately 55% directional accuracy), the appropriate response is a 10–20% weight tilt toward recent outperformers, not binary inclusion/exclusion.

• 4. Screen for nonlinearity with MI. If MI substantially exceeds Rank IC for a given alpha, the predictor-outcome relationship is nonlinear and warrants further investigation.

Alpha performance exhibits medium-term memory. The strongest predictor is the simplest: recent cumulative PnL. The framework above provides a rigorous measurement methodology and the empirical results establish the expected magnitude of the effect.

1. Stationarity and Unit Roots

A process Pₜ is integrated of order d, written I(d), if it requires d differencing steps to become stationary. I(0) is stationary; I(1) has a unit root, e.g. the random walk:

where εₜ ~ WN(0, σ²). Variance grows linearly: Var(Pₜ) = tσ².

The Augmented Dickey-Fuller (ADF) test regresses

and tests H₀: β = 0 (unit root) against H₁: β < 0 (stationary). Critical values are non-standard (Dickey-Fuller distribution). The Phillips-Perron test achieves the same via nonparametric correction.

The KPSS test reverses the null: H₀ is stationarity. Always run both ADF and KPSS — only when ADF rejects and KPSS does not reject do we have clean evidence of stationarity.

References: Dickey & Fuller (1979) "Distribution of the Estimators for AR Time Series with a Unit Root," JASA. Kwiatkowski et al. (1992) "Testing the Null Hypothesis of Stationarity," J. Econometrics. Phillips & Perron (1988) "Testing for a Unit Root in Time Series Regression," Biometrika.

2. Engle-Granger Two-Step

For two I(1) series Yₜ and Xₜ, Engle-Granger tests whether their linear combination is I(0). Step 1 — estimate by OLS:

The residual zₜ = Yₜ - α - β Xₜ is the spread. OLS is superconsistent here (β̂ converges at rate T). Step 2 — apply ADF to ẑₜ using Engle-Granger critical values (more conservative than standard ADF).

If zₜ is stationary, (Y, X) is cointegrated with vector (1, -β). Limitation: finds at most one relationship, and results depend on which variable is on the left-hand side.

References: Engle & Granger (1987) "Co-Integration and Error Correction," Econometrica. Phillips & Ouliaris (1990) "Asymptotic Properties of Residual Based Tests for Cointegration," Econometrica.

3. Johansen Procedure

Johansen models all k variables jointly in error correction form:

Π = αβ' where β contains r cointegrating vectors and α the adjustment speeds. Γᵢ are the short-run dynamics matrices. rank(Π) = r = number of cointegrating relationships.

The trace test evaluates H₀: rank(Π) ≤ r using:

Sequential testing from r = 0 upward. The max eigenvalue test uses -T ln(1 - λ̂ᵣ₊₁) for the sharper H₀: rank = r vs H₁: rank = r+1.

References: Johansen (1991) "Estimation and Hypothesis Testing of Cointegration Vectors in Gaussian VAR Models," Econometrica. Lütkepohl (2005) New Introduction to Multiple Time Series Analysis, Springer.

4. VECM Dynamics

The VECM describes how prices adjust to restore equilibrium:

β' Yₜ₋₁ - μ is the equilibrium error. α governs adjustment speed and direction. If |α₁| ≫ |α₂|, Y₁ is the follower and Y₂ the leader.

Half-life of mean reversion (discrete time):

Short half-lives (5–20 bars) → fast reversion, more opportunities. Long half-lives (50+) → slow convergence, higher carry risk.

References: Uhlenbeck & Ornstein (1930) "On the Theory of Brownian Motion," Physical Review. Leung & Li (2015) op. cit.

5. Ornstein-Uhlenbeck for Spreads

In continuous time, the spread follows an Ornstein-Uhlenbeck process:

θ > 0 is mean reversion speed, μ the long-run mean, σz the diffusion. Half-life: t₁/₂ = ln 2 / θ. Stationary distribution:

Stationary variance σz²/(2θ) captures the noise vs. reversion tradeoff.

Variance ratio diagnostic: VR(q) = Var(zₜ - zₜ₋q) / (q · Var(zₜ - zₜ₋₁)). Random walk → VR = 1. Mean reversion → VR < 1. Momentum → VR > 1.

References: Bertram (2010) "Analytic Solutions for Optimal Statistical Arbitrage Trading," Physica A. Leung & Li (2015) "Optimal Mean Reversion Trading with Transaction Costs," SIAM J. Financial Math.

6. Optimal Entry/Exit Thresholds

For an OU spread, the trader enters long at threshold a (below μ), exits at b (near μ), enters short at d (above μ), and exits at c. The value function V(z) between trades satisfies the HJB equation:

where ρ is the discount rate. For the symmetric case with costs c per round trip and μ = 0, the optimal entry threshold is approximately:

Exit at b = 0. Optimal entry tightens with faster reversion (larger θ) and widens with higher noise (larger σ_z) or transaction costs.

Exit at b = 0. Thresholds depend on θ (faster reversion → tighter entry), σz (more noise → wider entry), and transaction costs.

References: Wells (1996) The Kalman Filter in Finance. Harvey (1990) Forecasting, Structural Time Series Models and the Kalman Filter, Cambridge UP.

7. Kalman Filter for Time-Varying Hedge Ratios

In practice β drifts. The Kalman filter treats it as a latent state. State-space form:

Q controls how fast the hedge ratio can change. Let Σₜ denote the state covariance. Prediction: β̂ₜ|ₜ₋₁ = β̂ₜ₋₁|ₜ₋₁, Σₜ|ₜ₋₁ = Σₜ₋₁|ₜ₋₁ + Q. Update via Kalman gain:

Update: β̂ₜ|ₜ = β̂ₜ|ₜ₋₁ + Kₜ(Yₜ - β̂ₜ|ₜ₋₁Xₜ), Σₜ|ₜ = (1 - KₜXₜ)Σₜ|ₜ₋₁. The ratio Q/R governs responsiveness vs smoothness.

References: Engle (2002) "Dynamic Conditional Correlation," J. Business & Economic Statistics. Wells (1996) The Kalman Filter in Finance, Kluwer.

8. Dynamic Hedge Ratios

Three approaches for time-varying hedge ratios. Rolling OLS over W observations:

Simple but jumpy — sensitive to window choice and outliers entering/leaving.

Kalman filter weights all past observations exponentially via Q/R. Smooth by construction.

DCC-GARCH models time-varying correlations and volatilities. The implied hedge ratio:

DCC adapts to volatility regimes but requires more parameters.

References: Avellaneda & Lee (2010) "Statistical Arbitrage in the US Equities Market," Quantitative Finance. Gatev, Goetzmann & Rouwenhorst (2006) "Pairs Trading: Performance of a Relative-Value Arbitrage Rule," Rev. Financial Studies.

9. Multi-Pair Portfolios

Portfolios of pairs diversify across multiple mean-reverting spreads. PCA on the price matrix extracts common non-stationary factors; residuals are the mean-reverting component.

Markowitz-optimal spread allocation given z-scores z and covariance Σₛₚᵣₑₐd:

Diversification benefits arise when spread correlations are low.

Factor-neutral construction: impose F' w = 0 to zero out market/sector/style exposure, isolating pure mean-reversion alpha.

10. Regime Shifts in Cointegration

Cointegration can break. Trading a broken pair produces unbounded losses as the spread drifts while you expect reversion.

CUSUM monitors cumulative recursive residuals — boundary crossing signals a break. Gregory-Hansen allows one unknown break date:

where Dₜ = 1(t > τ) is a regime dummy and τ is the unknown break date. Bai-Perron generalizes to m breaks via dynamic programming.

Practical heuristic: flag if estimated half-life exceeds 2× its historical average. Regime-switching cointegration allows θ to depend on a Markov state — smoothed P(Sₜ = 1 | data) provides continuous cointegration confidence for position sizing.

References: Hamilton (1994) Time Series Analysis, Ch. 19. Bai & Perron (2003) "Computation and Analysis of Multiple Structural Change Models," J. Applied Econometrics. Gregory & Hansen (1996) "Residual-Based Tests for Cointegration in Models with Regime Shifts," J. Econometrics.

Related Articles

• Pairs Trading Crypto Perpetuals: The Methodology — Cointegration-based pairs trading on crypto perpetuals

• Pairs Trading Crypto Perpetuals: Backtest Results — 72 configurations swept across 901 crypto pairs

• Regression Methods Every Quant Should Know: Math, Insights, and Debugging — OLS to quantile regression, with quant applications

1. Equal-Weight Average

The simplest combination assigns identical weight to every signal. Given N forecasts f₁, f₂, …, f_N, the combined forecast is

No parameters need to be estimated, which means no estimation error can contaminate the output. This is the method's great strength and the reason it is surprisingly hard to beat in practice, a phenomenon known as the forecast combination puzzle [1, 2, 11].

To see why equal weighting works so well, decompose the mean squared error. If each signal has variance σ² and every pair shares correlation ρ, the MSE of the equal-weight average is

When signals are uncorrelated (ρ = 0), the error drops as 1/N, pure diversification. When signals are perfectly correlated (ρ = 1), combining adds nothing. The practical regime sits between these extremes: each new uncorrelated signal provides diminishing but real improvement, while correlated signals contribute less. The formula makes the imperative clear: seek signals with low pairwise correlation, not just high individual accuracy.

2. Inverse-Variance Weighting

Equal weighting treats a signal with an information coefficient of 0.08 the same as one with 0.02. Inverse-variance weighting corrects this by assigning weight proportional to precision:

This is the minimum-variance combination when signals are mutually uncorrelated. Precise signals dominate; noisy ones are downweighted. The combined forecast variance collapses to

This is always less than or equal to the variance of any individual signal, with equality only when a single signal has infinite precision. The method requires estimating each σᵢ², but these are univariate quantities; easy to estimate with modest data. The critical limitation is the uncorrelated-signals assumption. When signals share common factors or draw on overlapping information, inverse-variance weighting overallocates to a cluster of redundant signals while underweighting a lone independent signal. Correcting this requires the full covariance structure.

3. Markowitz on Alphas

The signal combination problem is structurally identical to portfolio optimization. Treat each signal as an "asset," its expected information coefficient μᵢ = 𝔼[ICᵢ] as the expected return, and the signal covariance matrix Σ as the risk. The optimal weight vector that maximizes the information ratio of the combined forecast is

where 𝟏 is the vector of ones and the denominator enforces ∑ wᵢ = 1. This is the tangency portfolio applied to the signal space [10]. It simultaneously accounts for signal strength (via μ), signal noise (via the diagonal of Σ), and signal redundancy (via the off-diagonal elements of Σ).

The problem is that this solution requires estimating both μ and Σ from historical data. With N signals, Σ has N(N+1)/2 free parameters. If N = 20 and you have two years of monthly data (T = 24), the sample covariance matrix is nearly singular. Small perturbations in the data produce wildly different weight vectors. The optimal solution in-sample becomes the worst solution out-of-sample. This is the same curse that plagues mean-variance portfolio optimization, and the remedies are the same: shrinkage.

4. Estimation Error and Shrinkage

The James-Stein estimator [3] demonstrates that, in dimensions N ≥ 3, shrinking the sample mean toward a common value always reduces expected squared error. Applied to signal ICs, the shrinkage estimator is

where μ̅ is the grand mean of estimated ICs and σ̂²_μ is the estimation variance. Signals with extreme estimated ICs are pulled toward the average, reducing the influence of sampling noise on the weight vector.

For the covariance matrix, the Ledoit-Wolf shrinkage estimator [4] blends the noisy sample covariance S with a structured target F (typically the diagonal matrix of variances or an equicorrelation matrix):

The optimal shrinkage intensity α* minimizes the expected Frobenius norm of the estimation error 𝔼[‖Σₛₕᵣᵤₙₖ − Σₜᵣᵤₑ‖_F²] and can be computed in closed form from the data. When T is small relative to N, α* is close to 1 and the estimator hugs the structured target. As T grows, α* declines and the sample covariance is trusted more. The combined effect of shrinking both μ and Σ is a weight vector that is far more stable across rebalancing periods, producing better out-of-sample combination even if in-sample fit is slightly worse.

5. Ridge and Lasso Combination

An alternative to shrinking the inputs is to regularize the combination directly. Frame the problem as a regression of realized returns rₜ on signal forecasts 𝐟ₜ = (f₁_,ₜ, …, f_N,t)^⊤:

With p = 2 (ridge regression), the penalty λ‖𝐰‖₂² shrinks all weights toward zero without eliminating any signal. The closed-form solution is 𝐰̂_ridge = (F^⊤ F + λ I)⁻¹ F^⊤ 𝐫, which is always well-conditioned regardless of collinearity among signals. Ridge implicitly performs a form of covariance shrinkage: the addition of λ I to the Gram matrix F^⊤ F is equivalent to inflating the diagonal of the signal covariance, pulling the eigenvalues away from zero.

With p = 1 (lasso [5]), the ℓ₁ penalty λ‖𝐰‖₁ drives weak signals' weights to exactly zero, performing automatic signal selection. This is valuable when many candidate signals are noise, the lasso discards them and concentrates weight on the few that carry genuine alpha. The elastic net [6] combines both penalties:

yielding sparse solutions that still handle correlated signals gracefully. In all cases, λ is chosen by time-series cross-validation, never by in-sample fit; respecting temporal ordering to avoid look-ahead bias.

6. Stacking with Cross-Validation

Stacking [7, 8] generalizes regularized regression by introducing a two-level architecture. At Level 1, each of the N base signals generates out-of-fold forecasts using K-fold cross-validation. For each fold k, signals are trained on T − T/K observations and produce predictions on the held-out T/K observations. This produces a matrix of out-of-fold forecasts F̂ ∈ ℝ^T × N where each row's predictions come from models that never observed that row's realized return.

At Level 2, a meta-learner is trained on (F̂, 𝐫) to find the optimal combination:

where g is the meta-learner's functional form and ℒ is the loss function. When g is linear and ℒ is squared error, stacking reduces to OLS on out-of-fold predictions, but critically, the out-of-fold construction eliminates the overfitting that would plague direct OLS on in-sample predictions. Nonlinear meta-learners (gradient-boosted trees, shallow neural networks) can capture interaction effects between signals, for instance, a momentum signal may be informative only when the mean-reversion signal is inactive. The cost is additional complexity and the risk of overfitting the meta-learner itself, which must be controlled by regularization or further cross-validation.

7. Turnover-Penalized Combination

Optimal combination in a frictionless world ignores the cost of acting on the combined forecast. In practice, if the optimal weights shift substantially each period, the resulting combined signal oscillates, generating excessive turnover and transaction costs that erode alpha. The turnover-penalized formulation augments the objective:

The second term penalizes changes in the combined forecast between periods. The solution tilts weights toward signals with slower decay, those whose autocorrelation is high and whose forecast revisions are small. A fast-decaying signal might have high IC but, after transaction costs, contribute negative net alpha to the combination.

An alternative penalizes weight instability directly rather than forecast turnover:

This keeps the combination weights themselves stable across rebalancing dates, which has the secondary benefit of making the strategy more interpretable and auditable. The two penalties are related but not identical: stable weights on volatile signals still produce high-turnover forecasts, while unstable weights on smooth signals may not. In practice, penalizing both, or equivalently, penalizing the turnover of the final position; gives the best results.

8. Bayesian Model Averaging

All methods so far select a single weight vector. Bayesian Model Averaging (BMA) [9] takes a fundamentally different approach: it averages over all possible combination models, weighted by their posterior probability. Given a set of candidate models M₁, …, M_K, Bayes' theorem gives

where P(data ∣ Mₖ) is the marginal likelihood, the probability of the observed data integrated over all parameter values under model Mₖ. The combined forecast is

The marginal likelihood naturally penalizes complexity because complex models spread their prior probability mass over a larger parameter space, reducing the density at the realized parameter values. This is a built-in Occam's razor: a model that fits the data well with few parameters earns a higher marginal likelihood than one that fits slightly better but requires many parameters. BMA handles genuine model uncertainty, it does not commit to one combination scheme but hedges across all of them. The practical challenge is computing P(data ∣ Mₖ), which requires integration over the parameter space and can be intractable for complex models. Approximations such as BIC-based weights (P(Mₖ ∣ data) ≈ exp(−tfrac12BICₖ) / ∑ⱼ exp(−tfrac12BICⱼ)) are widely used.

9. Regime-Conditional Mixing

Static combination weights assume the relative value of signals is constant over time. In reality, a momentum signal dominates in trending markets while a mean-reversion signal dominates in range-bound markets. Regime-conditional mixing allows the weights to depend on an observable state variable zₜ:

where zₜ might be realized volatility, a trend indicator, cross-asset correlation, or a hidden Markov model state [12]. The simplest implementation estimates separate weight vectors for each discrete regime, for instance, one set of weights when the VIX is above its 75th percentile and another when it is below. This doubles the number of parameters and requires sufficient data in each regime for stable estimation.

A smoother parametrization uses a softmax mapping:

which ensures weights are positive and sum to one for any value of zₜ, while allowing continuous variation. The parameters aᵢ and bᵢ are estimated by minimizing forecasting loss over the training sample. The risk is clear: with 2N parameters per regime variable, overfitting is a serious concern, and the approach is only justified when there is strong prior belief (and empirical evidence) that signal efficacy varies with the conditioning variable. Cross-validation with an expanding window, never a sliding window that could miss structural breaks; is essential.

The hierarchy of methods presented here reveals a fundamental tension at the heart of signal combination: more sophisticated methods extract more information from the data but require estimating more parameters, and each estimated parameter introduces its own source of error. The forecast combination puzzle, the empirical finding that equal weights often outperform optimized weights [11]; is a direct consequence of this tension. When data is scarce relative to the number of signals, the estimation error in optimal weights overwhelms the theoretical improvement over equal weighting. In practice, the most effective approach is to start with equal or inverse-variance weights, introduce Ledoit-Wolf shrinkage when you have sufficient history to estimate covariances, add ridge or lasso regularization when signal count grows large, and only move to regime-conditional mixing when both the signal count and data depth justify the additional complexity. Every step up the ladder must be validated out-of-sample, because in-sample improvement is nearly guaranteed and therefore meaningless. The best combination method is the one whose complexity is matched to the information content of your data, no more, no less.

References

[1] Bates, J.M. and Granger, C.W.J. (1969). "The Combination of Forecasts." Operational Research Quarterly, 20(4), 451-468.

[2] Timmermann, A. (2006). "Forecast Combinations." Handbook of Economic Forecasting, Vol. 1, 135-196.

[3] James, W. and Stein, C. (1961). "Estimation with Quadratic Loss." Proceedings of the Fourth Berkeley Symposium on Mathematical Statistics and Probability, Vol. 1, 361-379.

[4] Ledoit, O. and Wolf, M. (2004). "A Well-Conditioned Estimator for Large-Dimensional Covariance Matrices." Journal of Multivariate Analysis, 88(2), 365-411.

[5] Tibshirani, R. (1996). "Regression Shrinkage and Selection via the Lasso." Journal of the Royal Statistical Society: Series B, 58(1), 267-288.

[6] Zou, H. and Hastie, T. (2005). "Regularization and Variable Selection via the Elastic Net." Journal of the Royal Statistical Society: Series B, 67(2), 301-320.

[7] Wolpert, D.H. (1992). "Stacked Generalization." Neural Networks, 5(2), 241-259.

[8] Breiman, L. (1996). "Stacked Regressions." Machine Learning, 24(1), 49-64.

[9] Hoeting, J.A., Madigan, D., Raftery, A.E. and Volinsky, C.T. (1999). "Bayesian Model Averaging: A Tutorial." Statistical Science, 14(4), 382-401.

[10] Markowitz, H. (1952). "Portfolio Selection." The Journal of Finance, 7(1), 77-91.

[11] DeMiguel, V., Garlappi, L. and Uppal, R. (2009). "Optimal Versus Naive Diversification: How Inefficient is the 1/N Portfolio Strategy?" The Review of Financial Studies, 22(5), 1915-1953.

[12] Hamilton, J.D. (1989). "A New Approach to the Economic Analysis of Nonstationary Time Series and the Business Cycle." Econometrica, 57(2), 357-384.

Related Articles

• The 7 Layers of Ensembling in Systematic Trading — Seven practical layers for combining trading strategies

• From Point Estimates to Posterior: A Trader's Guide to Bayesian Deep Learning — Uncertainty-aware neural networks for trading

• Regression Methods Every Quant Should Know: Math, Insights, and Debugging — OLS to quantile regression, with quant applications

• Reference Guides - Regime Detection — HMM, change-point detection, and regime-aware trading

1. Close-to-Close Estimator

The simplest estimator uses only closing prices. Given n log-returns rₜ = ln(Cₜ / Cₜ₋₁), the sample variance is

where r̄ = n⁻¹∑ rₜ. This unbiased estimator serves as the efficiency baseline (1.0). All subsequent estimators are measured relative to it.

The fundamental deficiency is information loss: a day with wild swings that closes flat registers the same return as a day of perfect calm. For typical 20–30 day windows, sampling error is substantial — coefficient of variation on the order of √2/(n-1).

2. Parkinson Range Estimator

Parkinson (1980) showed that the daily high-low range contains far more volatility information. Under GBM with zero drift:

where Hₜ and Lₜ are the daily high and low. The constant 1/(4ln 2) ≈ 0.3607 arises from the Brownian bridge range distribution. Efficiency: ~5.2× versus close-to-close.

The limitation: assumes continuous paths with no jumps and zero drift. Overnight gaps and discrete tick sizes introduce downward bias of 10–20% for low-volatility instruments.

3. Garman-Klass Estimator

Garman and Klass (1980) derived the minimum-variance unbiased estimator using all four OHLC prices:

Coefficients come from maximum likelihood under GBM. Efficiency: ~7.4× versus close-to-close — nearly an order of magnitude from just four prices.

Like Parkinson, it assumes continuous diffusion and ignores overnight returns, making it unsuitable for instruments with significant gap risk without modification.

4. Yang-Zhang Estimator

Yang and Zhang (2000) explicitly handle opening jumps and non-zero drift by decomposing variance into three components:

where σ̂²ₒᵥₑᵣₙᵢgₕₜ is the overnight return variance ln(Oₜ / Cₜ₋₁), σ̂²ₒₚₑₙ₋cₗₒₛₑ is the intraday close-to-open variance, and σ̂²RS is the Rogers-Satchell estimator:

Rogers-Satchell is unbiased under drift. The mixing parameter k minimizes total variance:

Yang-Zhang is unbiased for drift + opening jumps — the practical ceiling of OHLC-based estimation. Going further requires intraday data.

5. Realized Variance

Realized variance (Andersen & Bollerslev 1998) sums squared intraday returns:

where rₜᵢ = ln P(tᵢ) - ln P(tᵢ₋₁) at M equally spaced intervals. For a continuous semimartingale d ln P = μ dt + σ(t) dW:

Realized variance converges to integrated variance with no parametric assumptions on σ(t) — it can be stochastic, path-dependent, or seasonally varying.

Typically sampled at 5-minute intervals (M = 78 per equity session). Sampling faster leads directly to the next problem.

6. Microstructure Noise Bias

The convergence RV → IV as M → ∞ assumes frictionless prices. Real prices are contaminated by microstructure noise (bid-ask bounce, discreteness, information asymmetry):

where εₜᵢ is noise with E[ε] = 0 and E[ε²] = ω². Under i.i.d. noise independent of the efficient price:

The bias 2Mω² grows linearly with M. At tick frequency (M > 20,000/day), noise dominates entirely. The variance of RVM around IV is U-shaped: decreasing with M at low frequencies (more data), increasing at high frequencies (more noise), with an optimum depending on ω² / IV.

7. Two-Scale and Multi-Scale Estimators

Zhang, Mykland & Ait-Sahalia (2005) proposed Two-Scale Realized Variance (TSRV): compute RV at two frequencies and debias:

Here RV⁽ˢˡᵒʷ⁾ averages subsampled RVs over K overlapping coarse grids, RV⁽ᶠᵃˢᵗ⁾ is all-tick RV, and n̄/n estimates the noise fraction. Convergence rate: n⁻²/³.

Zhang (2006) extended this to Multi-Scale RV (MSRV) with optimally weighted frequencies:

Weights aⱼ annihilate noise bias to a specified order. Optimal rate: n⁻⁴/⁵ — the best possible for linear estimators under unknown noise.

8. Realized Kernels

Barndorff-Nielsen, Hansen, Lunde & Shephard (2008) reinterpret noise-robust estimation through spectral analysis:

where γ̂ₕ = ∑ᵢ rₜᵢ₊ₕ rₜᵢ is the h-th realized autocovariance, k(·) is a kernel with k(0)=1 and k(x) → 0 as |x| → 1, and H is bandwidth. The kernel smoothly downweights noise-induced serial correlation.

Common choices: Parzen kernel (k(x) = 1 - 6x² + 6|x|³ for |x| ≤ 1/2, k(x) = 2(1-|x|)³ for 1/2 < |x| ≤ 1) and Tukey-Hanning k(x) = 1/2[1 + cos(π x)]. Optimal bandwidth:

Convergence rate: n⁻⁴/⁵, matching MSRV. The key advantage: robust to serially correlated noise and noise dependent on the efficient price, unlike TSRV which requires i.i.d. noise. This makes realized kernels the production standard.

9. HAR Model

Estimating past volatility is half the problem; forecasting is where economic value lies. Corsi (2009) proposed the HAR model:

where RV⁽ᵈ⁾ is daily, RV⁽ʷ⁾ = 1/5∑ⱼ₌₁⁵ RVₜ₋ⱼ⁽ᵈ⁾ weekly, and RV⁽ᵐ⁾ = 1/22∑ⱼ₌₁²² RVₜ₋ⱼ⁽ᵈ⁾ monthly — corresponding to day-trader, portfolio-manager, and institutional horizons.

Not formally long-memory, but practically indistinguishable from it. Out-of-sample performance matches or exceeds ARFIMA and GARCH with only OLS estimation. Extensions: HAR-J (jumps), HAR-CJ (continuous + jump), log-HAR (positivity via ln RV).

Production workflow: realized kernels → HAR forecasts → position sizing via σₜ₊ₕ = √RV̂ₜ₊ₕ.

10. Rough Volatility

Gatheral, Jaisson & Rosenbaum (2018) documented a striking regularity: log-volatility behaves like fractional Brownian motion with Hurst exponent H ≈ 0.1. The variogram scales as:

With H ≈ 0.1 across essentially all asset classes — far rougher than standard Brownian motion (H = 0.5). Volatility paths are Hölder continuous of order H: jagged oscillations at every scale.

For derivatives pricing, ATM implied volatility skew scales as:

With H = 0.1: ψ(τ) ~ τ⁻⁰·⁴, matching the observed power-law explosion of short-dated skew. Classical models (Heston) give ψ(τ) ~ τ⁰ — flat skew, contradicting data. The rough Bergomi model prices the full SPX surface with fewer parameters.

For forecasting, rough volatility explains HAR's success: the three-component structure approximates fractional integration's power-law kernel. The true relationship involves (1-L)ᴴ⁺¹/² rather than simple autoregression, and vol-of-vol scales as Δᴴ not Δ¹/².

Each estimator corrects a specific predecessor flaw. Close-to-close wastes intraday paths; OHLC estimators recover that information but assume continuous diffusions. Realized variance harnesses tick data but hits the noise barrier. Kernels and multi-scale methods separate signal from noise at near-optimal rates. HAR transforms estimates into forecasts. Rough volatility captures the true statistical nature of the process. The modern pipeline: realized kernels for estimation, HAR for forecasting, rough volatility for derivatives pricing.

Python Implementation

Compact implementations of every estimator above using NumPy and pandas.

Close-to-Close

import numpy as np
import pandas as pd

def vol_close_to_close(close: pd.Series, window: int = 20) -> pd.Series:
    log_ret = np.log(close / close.shift(1))
    return log_ret.rolling(window).std() * np.sqrt(252)

Parkinson

def vol_parkinson(high: pd.Series, low: pd.Series, window: int = 20) -> pd.Series:
    log_hl = np.log(high / low) ** 2
    return np.sqrt(log_hl.rolling(window).mean() / (4 * np.log(2)) * 252)

Garman-Klass

def vol_garman_klass(open: pd.Series, high: pd.Series,
                     low: pd.Series, close: pd.Series, window: int = 20) -> pd.Series:
    log_hl = np.log(high / low) ** 2
    log_co = np.log(close / open) ** 2
    gk = 0.5 * log_hl - (2 * np.log(2) - 1) * log_co
    return np.sqrt(gk.rolling(window).mean() * 252)

Yang-Zhang

def vol_yang_zhang(open: pd.Series, high: pd.Series,
                   low: pd.Series, close: pd.Series, window: int = 20) -> pd.Series:
    log_oc = np.log(open / close.shift(1))   # overnight
    log_co = np.log(close / open)             # open-to-close
    log_ho = np.log(high / open)
    log_lo = np.log(low / open)
    log_hc = np.log(high / close)
    log_lc = np.log(low / close)

    # Rogers-Satchell
    rs = (log_ho * log_hc + log_lo * log_lc).rolling(window).mean()
    # Overnight & open-to-close variances
    var_o = log_oc.rolling(window).var()
    var_c = log_co.rolling(window).var()

    k = 0.34 / (1.34 + (window + 1) / (window - 1))
    yz = var_o + k * var_c + (1 - k) * rs
    return np.sqrt(yz * 252)

Realized Variance

def realized_variance(price: pd.Series, freq: str = "5min") -> pd.Series:
    """Compute daily realized variance from intraday prices."""
    log_ret = np.log(price / price.shift(1))
    rv = log_ret.pow(2).resample("1D").sum()
    return rv[rv > 0]  # drop non-trading days

Two-Scale Realized Variance (TSRV)

def tsrv(price: pd.Series, K: int = 5) -> float:
    """TSRV for a single day of tick prices."""
    log_p = np.log(price.values)
    n = len(log_p) - 1

    # Fast scale: all ticks
    rv_fast = np.sum(np.diff(log_p) ** 2)

    # Slow scale: K subgrids
    rv_slow = 0
    for j in range(K):
        sub = log_p[j::K]
        rv_slow += np.sum(np.diff(sub) ** 2)
    rv_slow /= K

    n_bar = (n - K + 1) / K
    return rv_slow - (n_bar / n) * rv_fast

Realized Kernel (Parzen)

def parzen_kernel(x):
    x = np.abs(x)
    return np.where(x <= 0.5, 1 - 6*x**2 + 6*x**3,
           np.where(x <= 1.0, 2*(1 - x)**3, 0.0))

def realized_kernel(price: pd.Series, H: int = None) -> float:
    """Realized kernel with Parzen weights for a single day."""
    log_ret = np.diff(np.log(price.values))
    n = len(log_ret)
    if H is None:
        H = int(np.ceil(n ** 0.6))  # bandwidth ~ n^{3/5}

    # Realized autocovariances
    gamma = np.array([np.sum(log_ret[h:] * log_ret[:n-h]) for h in range(H + 1)])
    weights = parzen_kernel(np.arange(H + 1) / H)
    return gamma[0] * weights[0] + 2 * np.sum(weights[1:] * gamma[1:])

HAR Model

from sklearn.linear_model import LinearRegression

def har_forecast(rv_daily: pd.Series, horizon: int = 1) -> pd.Series:
    """Fit HAR(1,5,22) and return out-of-sample forecasts."""
    rv = rv_daily.dropna()
    rv_w = rv.rolling(5).mean()
    rv_m = rv.rolling(22).mean()

    df = pd.DataFrame({"rv_d": rv, "rv_w": rv_w, "rv_m": rv_m}).dropna()
    y = df["rv_d"].shift(-horizon).dropna()
    X = df.loc[y.index, ["rv_d", "rv_w", "rv_m"]]

    # Walk-forward: train on first 70%, predict rest
    split = int(len(X) * 0.7)
    model = LinearRegression().fit(X.iloc[:split], y.iloc[:split])
    forecast = model.predict(X.iloc[split:])
    return pd.Series(forecast, index=X.index[split:], name="rv_hat")

Rough Volatility: Estimating H

def estimate_hurst(log_rv: pd.Series, max_lag: int = 100) -> float:
    """Estimate Hurst exponent from log realized volatility variogram."""
    lags = np.arange(1, max_lag + 1)
    variogram = np.array([
        np.nanmean((log_rv.values[lag:] - log_rv.values[:-lag]) ** 2)
        for lag in lags
    ])
    # log(variogram) ≈ 2H * log(lag) + const
    valid = variogram > 0
    slope, _ = np.polyfit(np.log(lags[valid]), np.log(variogram[valid]), 1)
    return slope / 2  # H

Related Articles

• 5 Signal Scaling Tricks That Turn Model Predictions Into Actual Trades — From raw prediction to optimal position sizing

• Reference Guides - Regime Detection — HMM, change-point detection, and regime-aware trading

• Reference Guides - Market Impact Models — From Kyle's model to Almgren-Chriss

Starting Simple: Crossing the Spread

The most basic form of market impact is mechanical. A market order to buy pays the ask; the mid-price is halfway between bid and ask. So the immediate cost of a single-unit market order is half the bid-ask spread:

This is the floor — every market order pays at least this much. But most trades are bigger than one unit.

Walking the Book

When your order is large enough to consume all the liquidity at the best price, it starts eating into deeper levels. If ρ(p) is the density of resting limit orders at price p, then the total cost of buying quantity q is an integral over the local book shape:

This captures the mechanical reality: bigger orders consume liquidity at progressively worse prices. But it’s static — it ignores the market’s dynamic response. Real impact persists long after the book refills.

The Central Empirical Fact: The Square-Root Law

Decades of empirical work across equities, futures, FX, and crypto have converged on a remarkably universal result. The price impact of executing a total order of size Q scales as:

with δ ≈ 0.5 and c of order unity. This holds across markets differing by orders of magnitude in capitalisation, tick size, and microstructure.

Why this matters: doubling your order size does not double your impact — it increases it by √2 ≈ 1.41×. This concavity is why splitting large orders into smaller pieces works, and it’s the foundation of every execution algorithm.

Intuition: if the order book density is roughly uniform near the current price, consuming Q shares requires walking through a price range proportional to Q/ρ. But ρ itself scales with √V in a stationary market, so after normalisation you get ΔP ∝ √(Q/V). An alternative route: dimensional analysis. The only relevant scales are daily volatility σ, daily volume V, and order size Q. The only sub-linear combination with the right units is σ · √(Q/V).

What Happens After You Trade

Temporary vs Permanent Impact

When you finish executing, the price doesn’t stay at the peak. It partially reverts. This motivates splitting impact into two pieces:

• Permanent g(v) — the market’s Bayesian update about fundamental value given the order flow. This never reverts.

• Temporary h(v) — the premium for demanding immediacy: consuming liquidity faster than it naturally replenishes. This fades.

Empirically, roughly two-thirds of peak impact persists as permanent, while one-third reverts. You measure this by comparing the price during trading, shortly after, and long after.

Impact Decay Is a Power Law

After execution stops, the price path from peak to permanent impact follows:

where G₀ is peak impact, G∞ is asymptotic permanent impact, and the decay kernel follows a power law:

with γ typically between 0.3 and 0.7. The two-thirds rule (G∞/G₀ ≈ 2/3) connects to a deep consistency condition: in an efficient market, permanent impact must equal the expected price move conditional on a buy having occurred.

Theoretical Foundations

Kyle’s Lambda: Why Impact Exists

Kyle (1985) gave the first equilibrium explanation. A market maker faces a mix of informed and noise traders but can’t tell them apart, so she prices linearly in total order flow:

where ω is net signed volume and λ (the Kyle lambda) measures price sensitivity to flow:

When informed volatility σ_v is high relative to noise σ_u, each unit of flow carries more information and the market maker charges more. Kyle explains why impact exists as an equilibrium phenomenon, but the linear form turns out to be wrong at scale — real impact is concave (square-root), not linear.

The Bouchaud Propagator: Impact Has Memory

Bouchaud et al. proposed a fundamentally different view: impact is neither purely temporary nor purely permanent. The price is a sum over all past trades, each weighted by a propagator G that describes how impact decays:

where ε_s is signed volume at time s. If G(τ) is constant, impact is fully permanent. If it’s a delta function, it’s fully temporary. Empirically, neither — it’s a power law:

with β ≈ 0.5. This slow decay means the rigid temporary/permanent split is an approximation — in reality there’s a continuous spectrum of decay timescales. The propagator also connects to a deep fact: trade sign autocorrelation decays as τ^{-α} with α ≈ 0.5, and the propagator exactly compensates this to keep prices diffusive.

Optimal Execution: Almgren-Chriss

Almgren and Chriss (2000) turned the temporary/permanent decomposition into a practical optimisation. Liquidate X shares over N periods, trading n_k shares in period k at rate v_k = n_k/τ. Total execution cost:

A key result: total permanent cost is strategy-independent. No matter how you schedule the trade:

So the only thing you can optimise is the temporary cost plus a risk penalty:

subject to ∑n_k = X. The solution interpolates between TWAP (low risk aversion, minimise temporary cost) and front-loaded aggressive schedules (high risk aversion, minimise variance). The optimal trajectory is a hyperbolic sine, with curvature set by λ_{risk}σ²/η. Almgren-Chriss is the workhorse of institutional execution, though its linear impact assumption doesn’t capture the square-root scaling.

At Scale: Meta-Orders, Cross-Impact, and Latent Liquidity

Meta-Orders: Why Large Orders Are Cheaper Per Unit

A meta-order is the full parent order, split into hundreds of child orders over hours or days. The aggregate impact is concave:

This is a paradox: if each child order has roughly linear impact, aggregate impact should be linear too. The resolution is that the market responds. As a meta-order executes and the price moves, liquidity providers detect the directional flow. New limit orders appear on the impacted side, partially cushioning further impact. Other directional traders may pull back. The concavity is an emergent property of the multi-agent ecosystem, not the static book.

Formally, if each child has impact λ·q but the market recruits liquidity proportional to cumulative displacement:

In the continuum limit this recovers I(Q) ∝ Q^{1/2} — the square-root law emerges from a mechanistic agent-response model.

Cross-Impact: Trading One Asset Moves Another

Markets are correlated. Trading asset i moves the price of asset j:

where Λ_{ij} is the cross-impact matrix. It’s not symmetric — trading a liquid large-cap may barely move an illiquid small-cap, but the reverse can be large. The scaling follows the correlation structure:

Ignoring cross-impact when executing a correlated basket systematically underestimates costs: selling one asset pushes down all correlated assets before you sell them.

Latent Liquidity: The Hidden Supply Curve

The visible order book is only a fraction of the market’s willingness to trade. Most liquidity is latent — it would appear if the price moved enough. Let S(p) be the cumulative latent supply. The impact of buying Q is just the inverse:

If latent supply increases away from the current price (s(p) ∝ p^α), then:

For α = 1, this gives the square-root law. Latent liquidity explains several puzzles at once: why large orders are absorbed better than visible depth suggests (trading recruits hidden liquidity), why impact is concave (each unit meets increasing latent supply), and why impact partially reverts (once buying stops, recruited sellers withdraw and the price settles back).

Each model corrects the one before it. Spread-crossing ignores dynamics; Kyle adds equilibrium but predicts linear scaling; the square-root law captures the right scaling but has no mechanism; the temporary/permanent split adds time but is rigid; Almgren-Chriss makes it tractable; the propagator frees the temporal structure; cross-impact extends to portfolios; and latent liquidity provides the microeconomic foundation underneath it all.

Modern execution systems operate in the propagator framework, calibrated with cross-impact matrices, layering meta-order concavity and latent liquidity recruitment for realistic cost prediction across asset classes and horizons.

Related Articles

• Measuring Market Impact: 24M Trades, Two Exchanges, One Answer — Empirical market impact from 24M crypto trades

• Reference Guides - Optimal Execution — TWAP, VWAP, and optimal execution schedules

• Reference Guides - Order Book Dynamics — Queue dynamics, price formation, and microstructure

• Building a Market-Maker on Hyperliquid — Part I: Theory — The economics of market making and the spread

1. Queue as a Birth-Death Process

At price level p, let Q(p, t) denote total resting quantity. Three event types drive the queue:

• Limit order arrivals at rate λl (births)

• Market order executions at rate λm (deaths, from front)

• Cancellations at rate δ · q (deaths, proportional to queue size)

The queue evolves as a birth-death chain. The stationary mean queue size is:

with variance Q̄(1 + δQ̄/(λm + δ)) — over-dispersed relative to Poisson.

A price tick occurs when Q(pb, t) → 0 at the best bid (price falls) or Q(pₐ, t) → 0 at the best ask (price rises).

2. Zero-Intelligence Model

The ZI model (Smith et al. 2003) places limit orders uniformly in [p - L, p + L] with no strategic intent. Market orders arrive at rate μ. The equilibrium spread emerges endogenously:

Key insight: a well-defined spread, diffusive returns, and realistic depth profiles arise purely from order book mechanics — no rationality needed. The ZI model separates mechanical phenomena from those requiring strategic behavior.

3. Cont-Stoikov-Talreja Model

The CST model (2010) tracks the joint state (Qb, Qₐ) ∈ ℤ_+² as a continuous-time Markov chain with six event rates:

A mid-price move occurs at the first queue depletion. The probability the next move is upward:

Defining imbalance I = Qb / (Qb + Qₐ), the conditional probability of an up-move is nearly linear in I for moderate values and nonlinear in the tails.

4. Queue Reactivity (Hawkes Processes)

Real order flow exhibits clustering: market orders trigger cancellations, which trigger further cancellations, which trigger limit order refills. The Hawkes process captures this self-excitation. The intensity of event type i at time t:

The matrix αᵢⱼ encodes feedback loops:

The branching ratio n = ∑ⱼ αᵢⱼ/βᵢⱼ measures the fraction of endogenously triggered events. In equity markets n > 0.7 — most order book activity is reactive, not informational.

5. Diffusion Limit and First Passage

For large queues, the discrete birth-death process approximates a continuous Ornstein-Uhlenbeck diffusion:

where σQ² = λl + λm + δ Qₜ. This is an OU process with mean-reversion level Q̄ and speed δ.

Since price moves occur at queue depletion (Q → 0), the inter-move duration is a first-passage time. Starting from Q₀ = Q̄:

The exponential dependence means modest increases in queue depth dramatically reduce price-move frequency — explaining why deep-book instruments have lower tick-level volatility.

6. Order Flow Imbalance and Price Formation

The OFI framework (Cont, Kukanov & Stoikov 2014) quantifies how order flow maps to price changes. Over interval [t, t + Δ t]:

The contemporaneous price change follows:

with R² ≈ 0.40--0.65 at 10-second horizons. The impact coefficient links back to queue depth:

This closes the loop: order flow moves queues, queue depletion moves prices, depth governs the rate.

7. Multi-Level Depth Profile

The limit order density at distance x from mid-price follows a power law near the spread:

The book is sparse near the spread and denser further away. The multi-level depth ratio at depth k:

adds 5–15 percentage points of R² for 1-second returns beyond Level 1 imbalance alone, with marginal contribution decaying in k.

8. Queue Position Value

The value of being the k-th order in a queue of depth Q at the best bid:

Fill probability decays exponentially: P(fill ∣ k) ≈ e⁻k/Q^∗. The marginal value of advancing one position:

This is the rational willingness to pay for latency — a co-location upgrade that gains one queue position is worth Δ V per order.

9. Key Empirical Facts

• Queue lifetimes: heavy-tailed, power-law exponents in [1.5, 2.5]

• Fill rates: exponential decay in queue position; front-of-queue fills at 60–80%, back at 5–10% (large-tick stocks)

• Cancellation clustering: bursts triggered by correlated instrument moves; propagates across 2–3 price levels within milliseconds

• Intraday patterns: U-shaped arrival rates (open/close heavy); cancellation-to-arrival ratio relatively flat

• Mean-reversion: queue sizes revert on seconds-to-minutes timescale; speed inversely related to spread width

References

1. Smith, Farmer, Gillemot & Krishnamurthy (2003). Statistical theory of the continuous double auction. Quantitative Finance, 3(6), 481–514.

2. Cont, Stoikov & Talreja (2010). A stochastic model for order book dynamics. Operations Research, 58(3), 549–563.

3. Cont, Kukanov & Stoikov (2014). The price impact of order book events. Journal of Financial Economics, 104(2), 471–484.

4. Hawkes (1971). Spectra of some self-exciting and mutually exciting point processes. Biometrika, 58(1), 83–90.

5. Bacry, Mastromatteo & Muzy (2015). Hawkes processes in finance. Market Microstructure and Liquidity, 1(1), 1550005.

6. Bouchaud, Mézard & Potters (2002). Statistical properties of stock order books. Quantitative Finance, 2(4), 251–256.

7. Huang, Lehalle & Rosenbaum (2015). Simulating and analyzing order book data: The queue-reactive model. JASA, 110(509), 107–122.

8. Gould et al. (2013). Limit order books. Quantitative Finance, 13(11), 1709–1748.

9. Abergel & Jedidi (2013). A mathematical approach to order book modeling. IJTAF, 16(5), 1350025.

10. Obizhaeva & Wang (2013). Optimal trading strategy and supply/demand dynamics. Journal of Financial Markets, 16(1), 1–32.

11. Lehalle & Mounjid (2017). Limit order strategic placement with adverse selection risk. MSL, 3(1), 1750009.

12. Daniels, Farmer, Gillemot, Iori & Smith (2003). Quantitative model of price diffusion and market friction. PRL, 90(10), 108102.

Related Articles

• Reference Guides - Fill Probability Models — From Poisson to Hawkes: modeling limit order fills

• HFT Secrets 3/5: Microprice — The Fair Value Hidden in the Order Book — Volume-weighted fair value from the order book

• HFT Secrets 1/5: Order Flow Imbalance — Reading the Tape in Real Time — Computing and trading order flow imbalance

• Reference Guides - Market Impact Models — From Kyle's model to Almgren-Chriss

1. TWAP Baseline

The simplest possible schedule is Time-Weighted Average Price: divide the parent order X into equal slices and trade at a constant rate. The remaining inventory at time t is

and the trading rate is the constant v = X/T. TWAP implicitly assumes that temporary market impact is linear in trade rate, Δ S = η v, and that the impact coefficient η does not change throughout the day. Under these assumptions the total expected cost is simply

because each infinitesimal slice of size v dt costs η v in slippage, and integrating η v² over [0,T] gives η X²/T.

TWAP corresponds to zero risk aversion: the trader cares only about minimising expected impact and is indifferent to the variance of the execution cost. In a world where the mid-price follows a random walk with volatility σ, the cost variance of a TWAP schedule is maximal because inventory is held as long as possible. This is the baseline against which every subsequent model improves.

2. VWAP Extension

Intraday liquidity is not uniform. Equity markets exhibit a pronounced U-shaped volume profile: heavy volume at the open and close, thin volume over lunch. If temporary impact scales inversely with instantaneous volume, ηₖ = η₀ / Vₖ, then trading equal dollar amounts in every period is suboptimal. Volume-Weighted Average Price adapts the schedule so that the number of shares traded in period k is proportional to that period's expected volume:

The cost under time-varying impact becomes ∑ₖ ηₖ nₖ²/τ = η₀ ∑ₖ nₖ²/(Vₖ τ). Substituting the VWAP schedule shows that trading proportionally to volume minimises this sum, because it equalises the marginal cost of trading across periods. The proof is a direct application of the Cauchy-Schwarz inequality.

VWAP is the workhorse benchmark of agency execution desks. Its limitation is the same as TWAP's: it ignores price risk entirely. A trader who must sell a volatile stock still holds large inventory through thin midday periods, exposed to adverse price moves. To address this we need a framework that explicitly penalises risk.

3. Almgren-Chriss Linear Impact

Almgren and Chriss (2000) introduced the canonical formulation of optimal execution. The model decomposes market impact into two components: temporary impact η v that affects only the current trade, and permanent impact g nₖ that shifts the fundamental price for all subsequent trades. The trader chooses a discrete schedule ₁, …, nN\ with nₖ = xₖ₋₁ - xₖ to minimise the mean-variance objective

subject to the boundary conditions x₀ = X and xN = 0. The first term is temporary impact cost, the second is permanent impact cost, and the third is the risk penalty weighted by the trader's risk-aversion parameter λ.

A key insight from Almgren and Chriss is that the permanent impact contribution to expected cost is path-independent: regardless of the schedule chosen, the total permanent impact cost equals 1/2g X². This means permanent impact does not affect the optimal schedule at all. The optimisation reduces to a tradeoff between temporary impact (which favours slow trading) and variance (which favours fast trading), with λ controlling the balance.

4. Continuous-Time Solution

Taking the continuous-time limit τ → 0 and applying the Euler-Lagrange equation to the Almgren-Chriss objective yields the second-order ODE

where the urgency parameter is

This is a linear ODE with constant coefficients. The general solution subject to x(0) = X and x(T) = 0 is

The optimal trading rate follows by differentiation:

The dimensionless product κ T is the single number that governs the shape of the entire schedule. When κ T ≪ 1 (low urgency: the stock is not very volatile, the trader is not very risk-averse, or impact is high), the schedule is nearly linear and close to TWAP. When κ T ≫ 1 (high urgency), the schedule front-loads aggressively, liquidating most of the position early and then trickling out the remainder. The transition between these regimes is smooth and monotonic.

5. Efficient Frontier of Execution

As the risk-aversion parameter λ varies from zero to infinity, the optimal schedule traces out an efficient frontier in the plane of expected cost versus cost standard deviation, directly analogous to the Markowitz mean-variance frontier in portfolio theory. The expected cost of the optimal schedule is

and the variance of execution cost is

At λ = 0 (equivalently κ = 0), we recover TWAP: minimal expected cost η X²/T but maximal variance 1/3σ² X² T. As λ → ∞ (κ → ∞), the trader executes immediately at time zero, paying the maximum impact cost η X² / τmᵢₙ but bearing zero variance.

The frontier is convex and decreasing, meaning that initial reductions in variance are cheap in terms of added cost, but further reductions become progressively more expensive. In practice, most execution algorithms operate in the mildly risk-averse region where κ T is between 1 and 3, achieving a substantial variance reduction for a modest increase in expected cost. The frontier also provides a natural way to benchmark any execution algorithm: if a realised (cost, variance) pair lies northeast of the frontier, the algorithm is suboptimal.

6. Square-Root Impact Model

Empirical studies across equities, futures, and foreign exchange consistently find that market impact follows a concave power law rather than a linear relationship. The widely cited square-root law states

with δ ≈ 0.5 and c a dimensionless constant of order unity. This concavity means that doubling the trade size less than doubles the impact, which has profound implications for optimal scheduling.

Substituting square-root temporary impact into the continuous-time objective gives

The Euler-Lagrange equation is now nonlinear:

No closed-form solution exists for this ODE. Numerical solutions reveal a schedule that is qualitatively similar to the Almgren-Chriss hyperbolic-sine trajectory but with two important differences: execution is more aggressive at the start (because the concave impact function makes large early trades relatively cheaper) and gentler near the end. The total cost is lower than the linear-impact prediction for the same parameters, reflecting the empirical reality that impact is less punishing than linear models assume.

7. Obizhaeva-Wang Transient Impact

A fundamental limitation of the Almgren-Chriss framework is the assumption that temporary impact vanishes instantaneously after each trade. In reality, the order book takes time to replenish after a large trade. Obizhaeva and Wang (2013) model this through a transient impact kernel that decays exponentially:

where ρ is the resilience rate, the speed at which liquidity providers refill the book. The cumulative price impact at time t from a sequence of trades ₖ\ at times ₖ\ is

The optimal strategy in this model is qualitatively different from continuous Almgren-Chriss: the trader should execute in a series of discrete block trades separated by waiting periods, during which the order book recovers. The optimal inter-trade interval depends on the resilience rate ρ, with slower resilience dictating longer waits. In the limit ρ → ∞ (instant recovery), the model reduces to pure temporary impact and the Almgren-Chriss continuous schedule is recovered. In the limit ρ → 0 (permanent impact only), the schedule is irrelevant.

The Obizhaeva-Wang framework also explains why execution algorithms that "ping" the book with rapid small orders can be suboptimal: if resilience is slow, each successive ping hits a depleted book and the effective impact per share is higher than a single larger trade followed by a pause. The practical implication is that execution algorithms should estimate the resilience rate from order-book data and space trades accordingly.

8. Stochastic Liquidity

All preceding models treat the impact coefficient η as either constant or deterministically time-varying. In practice, liquidity is itself stochastic: bid-ask spreads widen and narrow unpredictably, depth fluctuates, and volatility clusters. When the impact coefficient η(t) is a known function of time (the simplest extension), the Euler-Lagrange equation becomes a variable-coefficient ODE:

Expanding the derivative gives η(t) ẍ + η̇(t) ẋ - λσ² x = 0, which must generally be solved numerically. The qualitative behaviour is intuitive: the optimal schedule concentrates trading in periods where η(t) is low (liquidity is abundant) and reduces trading when η(t) is high (liquidity is thin).

When η(t) is taken to be the reciprocal of the expected volume profile, the solution naturally produces something resembling a risk-adjusted VWAP. This provides the theoretical justification for VWAP-like strategies: they are not merely convenient benchmarks but approximate solutions to the optimal execution problem with realistic intraday liquidity variation. The fully stochastic case, where η(t) is a random process observed in real time, leads to a dynamic programming formulation. The trader must decide at each instant whether the current liquidity is good enough to trade aggressively or whether to wait for better conditions. The Hamilton-Jacobi-Bellman equation for the value function V(x, η, t) is

where ℒ_η is the infinitesimal generator of the liquidity process. Closed-form solutions exist only for special cases (e.g., mean-reverting Ornstein-Uhlenbeck liquidity), but the framework is general.

9. Signal-Aware Execution

The models above assume the trader has no view on future price direction. In practice, many institutional orders are initiated precisely because the trader has a short-term alpha signal. If the signal predicts that the price will move against the position at rate α, delaying execution is costly not just because of variance but because of expected adverse drift. The augmented objective is

The Euler-Lagrange equation becomes

This is a nonhomogeneous linear ODE. The particular solution shifts the entire trajectory: when α > 0 (the price is expected to fall, adverse for a seller), the optimal schedule front-loads more aggressively than the zero-alpha Almgren-Chriss solution. When α < 0 (the price is expected to rise, favourable for a seller), the trader can afford to slow down and reduce impact costs.

In the multi-asset setting, the trader liquidates a vector of positions x(t) ∈ ℝᵈ with cross-asset covariance Σ and vector of alpha signals α. The objective generalises to

where H is the matrix of impact coefficients (diagonal if cross-impact is negligible). The Euler-Lagrange system is a coupled set of linear ODEs that can be solved via matrix exponentials. Cross-asset covariance introduces a new effect: even if two assets have independent impact, correlated price moves mean that the optimal schedule for one asset depends on the inventory of the other. A risk-averse trader holding long positions in two highly correlated assets will liquidate both faster than if they were uncorrelated, because the combined position carries more risk.

10. Adaptive & RL-Based Execution

All closed-form models rely on parametric assumptions about impact, volatility, and liquidity that are at best approximations. Reinforcement learning offers a model-free alternative that can adapt to complex, non-stationary market dynamics. The execution problem maps naturally onto the RL framework: the state is sₜ = (xₜ, t, fₜ) where xₜ is remaining inventory, t is elapsed time, and fₜ is a vector of market features (spread, depth, recent volatility, order-flow imbalance). The action aₜ = vₜ is the trading rate. The one-step cost is

and the Bellman equation for the optimal value function is

Model-free approaches such as deep Q-learning or policy gradient methods learn V or the optimal policy π∗(s) = argminᵥ Q(s, v) directly from historical execution data or a realistic simulator. The agent discovers schedule shapes that resemble Almgren-Chriss in calm markets but deviate substantially during high-volatility episodes, news events, or periods of unusual order-flow.

The practical advantage of RL is its ability to incorporate features that are impossible to model analytically: queue position, limit-order-book shape, time-of-day effects, and cross-asset signals can all enter the state vector. The practical disadvantage is sample efficiency: execution is an episodic problem with sparse, noisy rewards (the total cost is revealed only at the end of the schedule), and the state space is high-dimensional. Sim-to-real transfer is also challenging because simulator fidelity directly bounds policy quality. Current best practice combines a parametric baseline (typically Almgren-Chriss) with an RL-based residual policy that learns corrections to the baseline, inheriting the baseline's stability while capturing nonlinear effects.

These ten formulations compose a hierarchy of increasing realism. TWAP is the zero-information, zero-risk-aversion baseline that every practitioner understands. Almgren-Chriss introduces the fundamental cost-risk tradeoff and delivers the elegant hyperbolic-sine schedule. The square-root impact model corrects the linear impact assumption to match empirical data. Obizhaeva-Wang adds order-book resilience and explains why discrete block trades can outperform continuous schedules. Stochastic liquidity models capture the reality that market conditions fluctuate unpredictably. Signal-aware execution integrates alpha forecasts into the schedule. And reinforcement learning handles the full complexity of real markets at the expense of requiring substantial data and infrastructure. In practice, most systematic execution desks start with an Almgren-Chriss backbone calibrated to their empirical impact estimates, layer on intraday volume adjustment to approximate stochastic liquidity, and increasingly augment with learned components for latency-sensitive or alpha-driven flow. The mathematical progression from TWAP to RL is not merely academic: it mirrors the actual evolution of execution algorithms deployed across global markets over the past two decades.

Related Articles

• Reference Guides - Market Impact Models — From Kyle's model to Almgren-Chriss

• Measuring Market Impact: 24M Trades, Two Exchanges, One Answer — Empirical market impact from 24M crypto trades

• Reference Guides - Order Book Dynamics — Queue dynamics, price formation, and microstructure

1. Gaussian Mixture Models

The simplest regime model treats returns as drawn from a mixture of Gaussian distributions with no temporal structure. Each observation is independently generated by one of K components, where the identity of the generating component is an unobserved latent variable z_t.

The unconditional density of returns takes the form

where \pi_k are mixing weights satisfying \sum_k \pi_k = 1, and each component has its own mean \mu_k and variance \sigma_k^2. A two-component mixture captures the empirical observation that equity returns exhibit a low-volatility, positive-drift regime (\mu_1 > 0, \sigma_1 small) and a high-volatility, negative-drift regime (\mu_2 < 0, \sigma_2 large).

Estimation proceeds via the Expectation-Maximization algorithm. The E-step computes the posterior responsibility of each component for each observation:

The M-step updates parameters using these posteriors: \hat{\mu}_k = \sum_t \gamma_t(k) r_t / \sum_t \gamma_t(k). The fundamental limitation is the absence of temporal dynamics — each observation is classified independently, so the model cannot express the empirical fact that regimes persist. Yesterday's regime tells us nothing about today's.

2. Hidden Markov Models

Hidden Markov Models remedy the temporal deficiency of mixture models by introducing state persistence. The hidden state S_t \in \{1, \ldots, K\} evolves as a discrete-time Markov chain governed by a transition matrix \mathbf{A} with entries

Conditional on the hidden state, returns are emitted according to a state-dependent distribution r_t \mid S_t = k \sim \mathcal{N}(\mu_k, \sigma_k^2). The crucial feature is that the diagonal elements of \mathbf{A} are large — typically A_{kk} \in [0.95, 0.99] — meaning regimes are sticky. Once the market enters a particular state, it tends to remain there for an extended period.

The filtered probability of being in regime k at time t, given all observations up to and including r_t, is computed via the forward algorithm. Define the forward variable \alpha_t(k) = P(r_1, \ldots, r_t, S_t = k), which satisfies the recursion

The filtered state probability is then P(S_t = k \mid r_1, \ldots, r_t) = \alpha_t(k) / \sum_j \alpha_t(j). This gives a real-time, probabilistic estimate of the current regime that incorporates the full history of observations through the recursive structure.

3. Hamilton's Regime-Switching Model

Hamilton (1989) extended the HMM framework to autoregressive dynamics by allowing all model parameters — not just the mean and variance, but also the autoregressive coefficients — to depend on the hidden regime. The Markov-switching autoregression takes the form

where the intercept \mu_{S_t}, persistence \phi_{S_t}, and volatility \sigma_{S_t} all switch with the hidden state. A canonical two-state specification might yield regime 1 as low-volatility trending (\mu_1 > 0, \phi_1 > 0, \sigma_1 small) and regime 2 as high-volatility mean-reverting (\mu_2 < 0, \phi_2 < 0, \sigma_2 large). The transition probabilities encode expected regime durations directly.

If p_{kk} = P(S_t = k \mid S_{t-1} = k) is the self-transition probability, then the expected duration of regime k follows a geometric distribution with mean

For p_{kk} = 0.98, the expected duration is 50 periods. Estimation proceeds by maximizing the likelihood via EM, where the E-step uses the Hamilton filter — a variant of the forward algorithm that conditions on lagged observables — and the M-step updates all regime-dependent parameters simultaneously. The key practical insight is that this model distinguishes not just between high and low volatility but between fundamentally different return-generating processes.

4. EM Algorithm for HMM Estimation

The Baum-Welch algorithm is the EM algorithm specialized to HMMs. The E-step deploys the forward-backward algorithm to compute posterior state probabilities. The forward variable \alpha_t(k) = P(r_1, \ldots, r_t, S_t = k) propagates information from past to present. The backward variable \beta_t(k) = P(r_{t+1}, \ldots, r_T \mid S_t = k) propagates information from future to present, satisfying

Combining forward and backward passes yields the smoothed posterior probability \gamma_t(k) = P(S_t = k \mid r_1, \ldots, r_T) = \alpha_t(k) \, \beta_t(k) / P(\text{data}), which uses the entire dataset rather than just past observations. The pairwise posterior \xi_t(j, k) = P(S_t = j, S_{t+1} = k \mid r_1, \ldots, r_T) is needed to update the transition matrix.

The M-step updates are weighted averages under these posteriors. The regime-specific mean is

and the transition probabilities update as \hat{A}_{jk} = \sum_t \xi_t(j,k) / \sum_t \gamma_t(j). The algorithm iterates E and M steps until convergence, monotonically increasing the log-likelihood at each iteration. A critical practical concern is sensitivity to initialization: the likelihood surface for HMMs is typically multimodal, so different starting points can yield qualitatively different solutions. Standard practice is to run multiple random initializations and select the solution with the highest likelihood, or to initialize from a preliminary GMM fit.

5. Bayesian Online Changepoint Detection

The Adams-MacKay (2007) framework takes a fundamentally different approach: rather than fitting a fixed number of persistent regimes, it tracks the posterior distribution over the run length r_t, defined as the number of time steps since the last changepoint. This is a fully online algorithm — each new observation updates the posterior without reprocessing history.

The key recursion factorizes the joint posterior into a growth probability (no changepoint) and a changepoint probability. The growth step extends the current run:

where H is the hazard rate — the prior probability of a changepoint at any given step — and P(x_t \mid r_{t-1}, x_t^{(r)}) is the predictive probability of the new datum under the current run's sufficient statistics. The changepoint step resets the run length to zero:

The hazard rate H acts as a tuning parameter: a higher H makes the detector more sensitive to changes but increases false alarms. For Gaussian data with unknown mean and known variance, the predictive distributions are Student-t, and sufficient statistics update incrementally. The posterior over run length gives a complete picture: a sharp peak at r_t = 0 indicates a recent changepoint, while a peak at large r_t indicates stability.

6. CUSUM and Sequential Tests

The Cumulative Sum (CUSUM) test, introduced by Page (1954), is the oldest and most theoretically grounded sequential changepoint detector. It monitors the cumulative deviation of observations from a reference level, triggering an alarm when the accumulated evidence exceeds a threshold.

For detecting a shift in mean from \mu_0 to \mu_1 > \mu_0, the upper CUSUM statistic is

where k = (\mu_0 + \mu_1)/2 is the allowance parameter (halfway between the null and alternative means) and x_t is the observed process. An alarm sounds when C_t^+ > h, where h is the decision threshold. The lower CUSUM C_t^- = \max(0, C_{t-1}^- - x_t + k) detects decreases. Together they form a two-sided detector.

The performance of CUSUM is characterized by the average run length (ARL) — the expected number of observations until an alarm. Under the null (no change), the ARL determines the false alarm rate and is approximately

for standardized observations. Under the alternative (after a true change), the ARL gives the detection delay. Page's test is optimal in the Lorden (1971) minimax sense: among all tests with a given false alarm rate, it minimizes the worst-case detection delay. In practice, CUSUM excels at monitoring specific parameters — a volatility estimate, a correlation coefficient, a strategy's Sharpe ratio — and triggering a regime flag when that parameter shifts.

7. Jump-Diffusion Models

Merton (1976) proposed an alternative framework where regime shifts manifest as discrete jumps superimposed on a continuous diffusion process. The asset price follows

where W is a standard Brownian motion, N is a Poisson process with intensity \lambda (expected jumps per unit time), and J \sim \mathcal{N}(\mu_J, \sigma_J^2) is the random jump size. The key distinction from HMM-style models is that regime shifts are instantaneous events rather than persistent states.

The resulting return distribution over a discrete interval is a countably infinite mixture of normals: conditional on n jumps occurring, the return is Gaussian with mean \mu + n\mu_J and variance \sigma^2 + n\sigma_J^2. Separating jump variation from continuous variation in realized data uses bipower variation, defined as

where r_{t,i} are intraday returns. Under mild conditions, BV_t converges to the integrated variance \int \sigma_s^2 \, ds even in the presence of jumps, because consecutive large returns (which jumps produce) are penalized by the product structure. The jump component is then estimated as JV_t = RV_t - BV_t, where RV_t is realized variance. Days with statistically significant JV_t flag potential regime-shift events that warrant recalibration of strategy parameters.

8. Turbulence Index

Kritzman and Li (2010) proposed a model-free approach to regime detection based on the Mahalanobis distance of multi-asset returns from their historical distribution. For a vector of n asset returns \mathbf{r}_t, the turbulence index is

where \hat{\boldsymbol{\mu}} and \hat{\boldsymbol{\Sigma}} are the sample mean vector and covariance matrix estimated over a trailing window. This distance measures how unusual the current observation is relative to recent history, accounting for both marginal volatilities and cross-asset correlations.

Under multivariate normality, d_t^2 follows a chi-squared distribution with n degrees of freedom. The turbulence threshold is therefore

where \alpha is the desired significance level (typically 0.05). Observations exceeding this threshold represent return patterns that are statistically anomalous — either because individual assets moved too much, or because the correlation structure broke down (e.g., historically uncorrelated assets moving together). The turbulence index requires no model fitting, no regime specification, and no parameter estimation beyond rolling moments. It is purely statistical, operates in real time, and naturally captures the multi-asset dimension that univariate regime models miss. Its simplicity is its strength: it detects when something unusual is happening without needing to specify what.

9. Regime-Conditional Strategy Allocation

Given a vector of regime probabilities p_t(k) = P(S_t = k \mid \text{data}) from any of the above models, the natural approach to portfolio construction is to blend regime-specific optimal portfolios. Let \mathbf{w}_k^* denote the optimal weight vector for regime k, computed via mean-variance optimization or Kelly criterion using regime-conditional parameters. The blended allocation is

This convex combination produces smooth transitions between regimes as the posterior probability shifts, avoiding the whipsaw trades that result from hard regime classification. When P(\text{bull}) = 0.8, the portfolio is 80% bull-optimal and 20% bear-optimal — a natural form of hedging against regime uncertainty.

The framework extends naturally to risk management. Regime-conditional value-at-risk uses the mixture distribution to compute tail risk:

This captures the fat tails that arise from regime mixing — a critical improvement over single-regime VaR. Position sizing should also be regime-conditional: the Kelly fraction f_k^* = \mu_k / \sigma_k^2 varies dramatically across regimes, and using the unconditional Kelly fraction leads to chronic over-betting during high-volatility periods. The most aggressive form of regime-conditional allocation is binary: if P(\text{crisis}) > \tau for some threshold \tau, reduce all positions to zero and hold cash until the crisis probability subsides.

10. Multi-Regime and Duration-Dependent Models

Two-state models capture the dominant bull-bear dichotomy but miss important intermediate dynamics. Extending to K = 3 or more regimes allows richer descriptions: a four-regime model might distinguish bull (trending up, low vol), calm (flat, low vol), correction (down, moderate vol), and crisis (down sharply, high vol, correlation spike). The challenge is that the number of transition parameters grows as K(K-1), and identification becomes difficult with limited data.

A deeper limitation of standard HMMs is the assumption that the transition probability out of a regime is constant regardless of how long the process has been in that state. Empirically, regime duration matters: the probability of a bull market ending after 6 months differs from the probability of it ending after 36 months. Duration-dependent models replace the constant transition probability with a hazard function h(d) that depends on the sojourn time d:

where D_t counts the time spent in the current state. An increasing hazard function h_k(d) — the longer a regime persists, the more likely it is to end — captures the empirical regularity that expansions and contractions have finite expected lifetimes and become increasingly fragile as they age. Semi-Markov models formalize this by replacing the geometric sojourn distribution of standard HMMs with arbitrary parametric families (Weibull, log-normal).

At the Bayesian nonparametric frontier, the infinite Hidden Markov Model (iHMM) places a hierarchical Dirichlet process prior over the transition distributions, allowing the number of regimes to grow with the data. The generative model is

where each row of the (now infinite) transition matrix is drawn from a Dirichlet process with concentration \alpha and base measure \beta. In practice, the posterior concentrates on a finite number of active states determined by the data, sidestepping the model selection problem entirely. This is particularly appealing in financial applications where the true number of market regimes is unknown and may itself change over time.

The hierarchy of regime detection methods moves from static classification (Gaussian mixtures) through dynamic state models (HMMs, Hamilton switching) to online detection (Bayesian changepoint, CUSUM) and finally to multi-asset anomaly detection (turbulence index). Each approach navigates the fundamental tradeoff between detection speed and false alarm rate: aggressive detectors identify regime changes quickly but trigger frequent false signals that generate costly whipsaw trades; conservative detectors avoid false alarms but react too slowly to protect capital. In practice, the most robust systems combine multiple detectors operating at different timescales: a Hidden Markov Model for structural regime identification over weeks and months, a turbulence index for real-time multi-asset anomaly detection, and CUSUM monitors on specific strategy parameters to flag calibration drift. The hardest part of regime detection is not identifying that a regime change has occurred — it is acting on that identification quickly enough to matter while maintaining the discipline to ignore the many false signals that any sensitive detector will produce.

Related Articles

• From Point Estimates to Posterior: A Trader's Guide to Bayesian Deep Learning — Uncertainty-aware neural networks for trading

• The 7 Layers of Ensembling in Systematic Trading — Seven practical layers for combining trading strategies

• Reference Guides - Signal Combination and Ensembling — From equal weights to Bayesian model averaging

The Problem

Every trading screen shows the "mid price" -- the average of the best bid and best ask. Simple, intuitive, universally used.

And wrong.

Consider: BTC bid is $87,250 with 10 BTC resting. Ask is $87,251 with 0.1 BTC. The mid is $87,250.50. But where do you think the next trade will print?

With 100x more volume supporting the bid, the fair value is much closer to the ask. The mid ignores this completely. The microprice does not.

The Theory

Stoikov (2018) formalized what market makers have always known intuitively: the volume-weighted mid is a better estimator of fair value than the arithmetic mid.

The microprice is:

microprice = ask_price * I + bid_price * (1 - I)

where I = bid_size / (bid_size + ask_size)

When the bid is larger than the ask (I > 0.5), the microprice moves toward the ask -- reflecting the higher probability that the next price move is upward. When the ask dominates (I < 0.5), it moves toward the bid.

The microprice bias -- the deviation from the mid in basis points -- is our trading signal.

Real Data: BTC Perpetual Order Book

Here's a 10-minute window from a single day (March 14, 2026) of BTC perpetual futures on Binance:

The microprice (blue) constantly dances around the mid (gray). When it pulls above the mid (positive bias), it signals upward pressure. When it dips below, downward pressure. The lower panel shows this bias in basis points.

The S-Curve: Imbalance Predicts Direction

The relationship between book imbalance and forward returns follows a characteristic S-curve:

When the bid dominates (imbalance > 0.5), forward returns are positive. When the ask dominates (imbalance < 0.5), returns are negative. The relationship is monotonic and approximately linear in the middle, with saturation at the extremes.

This is not a coincidence -- it's the market's price discovery mechanism at work.

How Good Is the Microprice?

We benchmark microprice against the naive mid on 5 days of data (5 x ~800K snapshots):

• Microprice IC: 0.1014 -- the bias predicts the direction of the next 1-second return

• Directional hit rate: 26.2% -- microprice correctly predicts the direction of the next move more than half the time

• MSE improvement: 0.3% -- microprice is a tighter estimator of the next observed price than the mid

A 26.2% hit rate sounds modest, but at ~800K predictions per day, it's enormously significant statistically. And in HFT, you compound these small edges across millions of observations.

Book Imbalance Is Not Uniformly Distributed

An important subtlety: the order book is not balanced half the time.

The distribution is not centered at 0.5 -- it has fat tails on both sides, with occasional extreme imbalances (0.05 or 0.95) that represent moments of very one-sided liquidity. These are the highest-conviction microprice signals.

When Does Microprice Work Best?

The microprice signal's predictive power depends on the spread:

When the spread is tight, the microprice is more informative -- both the signal and the potential profit per tick are larger relative to the cost. When the spread is wide, the signal is noisier and the cost of acting on it is higher.

This is why microprice is most useful in liquid markets (BTC, ETH perps) where the spread is typically 1 tick.

The Implementation

The microprice computation is trivially simple:

def microprice(bid_price, bid_size, ask_price, ask_size):
total = bid_size + ask_size
imbalance = bid_size / total
return ask_price * imbalance + bid_price * (1 - imbalance)

def microprice_signal(bid_price, bid_size, ask_price, ask_size):
mid = (bid_price + ask_price) / 2
mp = microprice(bid_price, bid_size, ask_price, ask_size)
return (mp - mid) / mid * 10_000  # bias in bps

Complexity: O(1) per update. No lookback, no parameters, no state. This is the purest form of order book signal.

Key Takeaways

1. The mid price is wrong. It ignores the most basic piece of information in the order book: relative volume at the best bid and ask.

2. Microprice has an IC of 0.1014 for 1-second forward returns on BTC -- small but highly significant.

3. It works best when spreads are tight -- exactly when you want to be trading.

4. The imbalance-return relationship is an S-curve -- linear in the middle, saturating at extremes.

5. Zero parameters. Unlike OFI (which aggregates over time) or VPIN (which requires a volume bar size), microprice is completely parameter-free.

Microprice is not just a signal -- it's the correct way to think about fair value in a limit order book. Every HFT firm uses some variant of this as the anchor for their quoting engine.

Next up: Avellaneda-Stoikov -- given a fair value estimate, how do you set optimal bid and ask quotes?

This post is part of the HFT Secrets series -- 5 deep dives into the building blocks of high-frequency trading, each with real data from our crypto data lake.

For educational purposes only. Not investment advice.

Related Articles

• Reference Guides - Order Book Dynamics — Queue dynamics, price formation, and microstructure

• Building a Market-Maker on Hyperliquid — Part I: Theory — The economics of market making and the spread

If you trade BTC perpetual futures on two different exchanges, do you pay the same price for moving the market? The answer matters: for anyone building execution algorithms, routing orders, or running transaction cost analysis, venue-specific impact is the difference between a good fill and a bad one.

To find out, I ran the same market impact pipeline on two datasets from February 2026:

• OKX: 11,919,988 trade events, built from 83.5M raw trades and 15.8M L2 snapshots (20 depth levels)

• Binance: 12,792,950 trade events, built from 67M raw trades and 20.2M L2 snapshots (10 depth levels)

Both datasets cover BTC-USDT perpetual futures over the same 28-day window. Same asset, same month, different venues. Here is what I found.

Step 1: Defining a Trade Event

Raw exchange trades are too granular to study impact directly. A single "market order" might appear as dozens of fills as it walks through the order book. So the first step is to aggregate: I group consecutive same-side trades within 100ms into a single event, recovering the atomic unit of aggression.

Right away, a key difference emerges. The median OKX event is 0.010 BTC ($689 notional) with 7 fills, while the median Binance event is 0.031 BTC ($2,114 notional) with 5 fills. OKX events are roughly 3x smaller in notional terms. Both exchanges have similar depth at the touch (~3 BTC), so the typical event on either venue consumes less than 2% of available liquidity. These are mostly single-contract trades — the median OKX event is just 1 contract (0.01 BTC).

Event size distributions (log scale). Both venues are dominated by small events. Median OKX event is 0.01 BTC ($689), Binance is 0.031 BTC ($2,114). Both consume less than 2% of the touch, but the right tail differs — OKX has more extreme outliers.

Step 2: Measuring Impact Across Horizons

For each event, I measure the absolute mid-price change at six horizons: 100ms, 500ms, 1s, 5s, 30s, and 60s. The result is an impact curve: how much does the price move, and how does that grow with time?

Average absolute impact in basis points. OKX shows consistently higher impact, with the gap widening at longer horizons (9 bps at 60s vs 8 bps on Binance).

OKX shows higher average impact at every horizon, and the gap widens with time. At 100ms the difference is small (~0.03 bps), but by 60 seconds OKX impact is roughly 1 bps higher. This is notable because OKX events are actually smaller — the higher impact reflects a different participant mix and order flow composition rather than event size alone.

Breaking this down by event size quintile confirms the classic pattern: larger events cause more impact at every horizon, on both exchanges. Both exchanges have comparable depth at the touch (~3 BTC), and the typical event on either venue consumes less than 2% of it. The quintile separation is driven by the right tail: Q5 events can be 100-1000x larger than the median, large enough to sweep multiple book levels.

Impact by notional size quintile. Q5 (largest 20% of events) causes 2-3x more impact than Q1 (smallest). The separation grows with horizon as larger trades carry more information content.

Step 3: Do the Classic Models Fit?

Two classical models dominate the academic literature. The square-root law (Almgren-Chriss) predicts that impact scales as the square root of normalised order size: beta = 0.5. Kyle's lambda models impact as linear in signed volume: buy 1 BTC, move the price by lambda basis points.

Out of the box, the square-root law is flat: beta near zero on both exchanges (OKX: -0.027, Binance: -0.032), R-squared below 0.01. But it turns out the fit is sensitive to two modelling choices.

First, the volume lookback window. The default 30-second trailing volume actually produces a negative beta — because short-term volume clustering is inversely correlated with per-event impact. Extending to daily volume flips the sign: beta becomes +0.02 to +0.04, in the right direction but still far below 0.5.

Second, the omitted variables. Almgren-Chriss includes a volatility term (σ), but the naive fit ignores it. Adding log(σ) and log(spread) as controls improves R-squared 10x: from 0.4% to 4.4% on OKX and 3.4% on Binance. But beta barely moves — it stays around 0.02-0.04 regardless. The spread coefficient is actually the strongest predictor in the parametric model: wider spreads mean more impact, independent of size.

So the square-root law fails at the individual event level — but it was never meant for single 100ms book sweeps. It was designed for meta-orders: parent orders split into hundreds of child executions over minutes to hours. To test this, I aggregated all order flow into non-overlapping time windows at increasing scales (1s, 5s, 30s, 1min, 5min, 30min, 1hr). Within each window I compute participation rate = |net imbalance| / total volume and impact = |price change| in bps, then fit the square-root relationship. The result confirms the theory: beta rises monotonically from ~0 at the event level toward 0.3-0.5 at hourly aggregation. At the 1-hour scale, the fit recovers the classic concave relationship between size and impact. The signal was always there — it just requires the right aggregation level to emerge from the noise.

Kyle's lambda tells a consistent story. Both exchanges have comparable depth at the touch (~3 BTC), and both have events that are small relative to that depth (<2% of the touch). The fitted lambdas are in the same ballpark: OKX lambda = 0.1294 versus Binance lambda = 0.0757. On OKX, the fitted value is 86% of the theoretical 1/(2*depth) = 0.1505. On Binance, it is 60% of theory. Both are reasonable matches — the linear model is a decent approximation when events are small relative to depth.

OKX's lambda is higher (1.7x Binance), despite having similar depth, because OKX has higher per-event impact on average. This likely reflects differences in the information content of order flow: OKX flow may carry more signal per unit volume, consistent with a more institutional participant mix.

R-squared is only 1% — but that is expected. An individual trade explains ~1% of the subsequent 1-second price variance. The other 99% is other trades arriving, public information, and the random walk.

Top left: fitted beta vs aggregation window — at event level beta is near zero, but it rises monotonically as we aggregate into longer windows, approaching the theoretical 0.5 (red dashed) at hourly scale. The square-root law emerges when individual events are aggregated into virtual meta-orders. Top right: Kyle's lambda binned by signed-volume ventile — both exchanges show clear monotonic slopes. Bottom left: impact decay on log-log tracks the random-walk sqrt(t) reference (dashed grey). Bottom right: parametric summary including best aggregation-level beta.

Step 4: What Actually Drives Impact?

Even the best parametric specification — size, volatility, and spread combined — explains only 4% of impact variance. Kyle's lambda captures direction but stays around 1%. Can a richer model close the gap? I trained LightGBM regression models with 49 microstructure features per horizon and exchange, including event characteristics (size, trades, duration, aggressiveness), order book state (spread, depth at multiple levels, imbalance, slope), and recent market conditions (volatility, trade intensity, returns).

The answer is yes, dramatically. On both exchanges, a single feature dominates: aggressiveness, defined as how far an order walks through the book relative to available depth. It captures 52% of total importance on OKX and 41% on Binance. This is intuitive: an order that consumes five price levels will move the price more than one that only hits the top of book.

The second most important feature reveals a venue difference. On Binance, number of trades per event matters much more (19% vs 7% on OKX). Since both venues have small median events, the distinction is about how order flow fragments differently: Binance has more multi-fill events where the fill count is a strong signal of sweep aggressiveness.

Top 15 features ranked by LightGBM gain importance. Aggressiveness dominates on both venues (52% on OKX, 41% on Binance). On Binance, n_trades is the clear second feature (19%); on OKX, aggressiveness is so dominant that remaining features contribute modestly.

Step 5: How Well Can We Predict Impact?

OKX models outperform Binance at every horizon. At 100ms, R-squared = 0.458 on OKX vs 0.425 on Binance. At 500ms the gap is dramatic: 0.499 vs 0.203. By 60 seconds both converge toward zero as diffusion noise dominates.

Why is OKX more predictable? Despite having smaller median events, OKX's order flow carries more directional information. The aggressiveness feature (how far an order walks through the book) dominates even more on OKX (52% of importance vs 41% on Binance), suggesting that OKX events — while small in median terms — are more discriminative in their book-sweeping behaviour. The right tail of the size distribution is also fatter on OKX, with more large events that mechanically move price.

R-squared (left) and MAE (right) by horizon. OKX models outperform Binance at every horizon, with the biggest gap at 500ms (0.50 vs 0.20). Both decline toward zero at 30-60s as diffusion noise takes over.

Step 6: Microstructure Conditioning

Impact is not a fixed number. It depends on the market state when the event arrives. I conditioned on four dimensions to compare the exchanges:

• Buy vs sell: near-perfect symmetry on both venues, as expected for a liquid perpetual contract.

• Spread: wide-spread periods produce 30-40% more impact, consistent on both exchanges.

• Volatility: high-volatility regimes amplify impact by 3-4x at the 60s horizon. This effect is massive and consistent across venues.

• Overall level: OKX sits above Binance across all conditioning slices.

Impact conditioned on market state. Buy/sell symmetry holds on both venues. Wider spreads and higher volatility amplify impact substantially. OKX consistently sits above Binance.

Step 7: Impact or Random Walk?

Not all impact sticks. Some is mechanical (the immediate spread-crossing cost) and some is informational (the market learns from the trade). The parametric decay fit (bottom left of the figure above) gives a clue: the decay exponent gamma is approximately -0.5 on both exchanges. That is exactly the exponent of a random walk, where expected absolute displacement grows as the square root of time.

This means that our impact curves — which show |impact| growing from 0.3 bps at 100ms to 8-9 bps at 60s — are dominated by diffusion, not by true information-driven impact. Most of the long-horizon "impact" is just the price wandering randomly after the trade, not a permanent shift caused by the trade.

The diffusion-to-impact ratio (60s / 100ms) quantifies this. Small events (Q1) have ratios around 35-37x: nearly all of the 60s price move is pure noise. Large events (Q5) show ratios of 16-20x: still dominated by diffusion, but less so. Larger trades carry more genuine information, and a higher fraction of their measured impact is real.

This is consistent across both exchanges — it is a fundamental property of market microstructure, not a venue artefact. Separating true permanent impact from diffusion would require a propagator-style analysis (Bouchaud et al.), conditioning on the sign sequence of subsequent trades. That is a topic for a follow-up.

Left: impact paths for Q1 (smallest) vs Q5 (largest) events. Right: the diffusion-to-impact ratio drops from ~37x for small events to ~18x for large events, on both venues — larger trades contain more genuine information.

Takeaways for Practitioners

• Venue selection matters: OKX shows higher average impact at every horizon despite having smaller median events, suggesting more informed order flow. Binance offers lower expected impact in absolute terms.

• Kyle's lambda works when events are small relative to depth: on both exchanges (events consume less than 2% of the touch), the linear model matches theory within 40%. The square-root law needs meta-order aggregation to work at all. For prediction, you need richer features and nonlinear models.

• Aggressiveness is the key feature: on both exchanges, how far an order walks through the book explains ~40% of predicted impact. If you only track one thing, track this.

• Predictability has a horizon: mechanical impact (100ms-1s) is highly predictable; beyond 5 seconds, diffusion takes over and models lose power.

• Volatility is the biggest regime switch: high-vol periods amplify impact 3-4x. Any execution algorithm that ignores the current volatility regime is leaving money on the table.

Related Articles

• Reference Guides - Market Impact Models — From Kyle's model to Almgren-Chriss

• Reference Guides - Order Book Dynamics — Queue dynamics, price formation, and microstructure

• Reference Guides - Optimal Execution — TWAP, VWAP, and optimal execution schedules

The Problem

It's a quiet Tuesday afternoon. BTC is trading at $87,000, volume is average, volatility is low. Then, in the span of 3 minutes, the price drops $2,000. By the time you react, the move is over.

The question every market maker asks: could I have seen this coming?

VPIN -- the Volume-Synchronized Probability of Informed Trading -- is designed to answer exactly this question. It measures the probability that the current order flow is dominated by informed traders, and it spikes before large price moves.

The Theory

VPIN was introduced by Easley, Lopez de Prado & O'Hara (2012) as a real-time proxy for the probability of informed trading. The core idea:

1. Volume bars, not time bars. Resample trades into equal-volume buckets instead of equal-time intervals. This ensures each bar contains the same amount of "information" regardless of market activity.

1. Bulk Volume Classification (BVC). Instead of classifying each individual trade as buy or sell (which requires matching against the order book), use the price change within the bar to probabilistically classify the entire bar's volume.

1. VPIN = rolling average of |buy_vol - sell_vol| / total_vol. When informed traders are active, volume becomes one-sided. VPIN captures this.

The formula:

BVC_buy_fraction = CDF(z_t)    where z_t = price_change / sigma
VPIN_n = (1/n) * sum(|V_buy_i - V_sell_i| / V_total_i)  for i in [t-n, t]

Volume Bars vs Time Bars

Before computing VPIN, we need to understand why volume bars matter. Here's the same BTC trading session viewed through both lenses:

Time bars (top) have wildly different volumes -- a 1-minute bar at 3am contains a fraction of the information of a 1-minute bar during the US session. Volume bars (bottom) normalize this: each bar contains the same amount of traded volume, so each bar carries roughly the same statistical weight.

BVC: Does It Actually Work?

Bulk Volume Classification uses the CDF of normalized price changes to probabilistically assign buy/sell labels. Since we have actual trade-side labels from the exchange, we can check:

Raw BVC predictions are directionally accurate but attenuated — the predicted range spans 0-100% while actuals compress to ~35-68%. This is expected in ultra-liquid markets where each volume bar contains thousands of trades. After isotonic calibration (a simple monotonic mapping fitted on the data), the expected calibration error drops from 0.158 to effectively zero. BVC captures the direction and relative magnitude of order flow, and with one-time calibration, it becomes a well-calibrated probabilistic classifier.

Real Data: VPIN on BTC Perpetual Futures

We computed VPIN from 5 days of tick-by-tick BTC trades on Binance Futures (March 10-14, 2026).

The red-shaded regions mark periods where VPIN exceeds its 90th percentile (0.062). Notice how these high-VPIN episodes tend to precede or coincide with sharp price moves. The market maker's nightmare -- being on the wrong side of informed flow -- shows up as VPIN spikes.

VPIN Predicts Future Volatility

The practical question: does high VPIN actually predict what comes next?

We compute a VPIN surprise score (how far current VPIN is above its recent average) and sort readings into quintiles. The top quintile experiences ~20% larger forward price moves than the bottom quintile over the next 5 minutes. The relationship is clear: when VPIN spikes above its baseline, larger price moves follow.

This is why market makers widen their quotes when VPIN spikes. The expected adverse selection cost just went up.

The Distribution of Informed Trading

How often is the market "toxic"?

• Median VPIN: 0.046 -- the "normal" state

• 90th percentile: 0.062 -- elevated informed trading, widen quotes

• 99th percentile: 0.079 -- extreme toxicity, consider pulling quotes entirely

Most of the time, VPIN is well-behaved. But the tail events are where market makers get hurt -- and where VPIN earns its keep as an early warning system.

The Implementation

Core VPIN computation with BVC:

from scipy.stats import norm

def compute_vpin(prices, volumes, bar_size, n_buckets=50):
# Step 1: Normalized returns for BVC
log_ret = np.diff(np.log(prices), prepend=np.log(prices[0]))
z = log_ret / rolling_std(log_ret, window=10000)

# Step 2: BVC classification
buy_frac = norm.cdf(z)
buy_vol = volumes * buy_frac
sell_vol = volumes * (1 - buy_frac)

# Step 3: Create equal-volume bars
bar_buy, bar_sell = aggregate_to_volume_bars(
buy_vol, sell_vol, bar_size
)

# Step 4: VPIN = rolling mean of |imbalance| / total
imbalance = np.abs(bar_buy - bar_sell)
total = bar_buy + bar_sell
vpin = pd.Series(imbalance / total).rolling(n_buckets).mean()

return vpin

Complexity: O(n) for the full pipeline. The only parameter that matters is bar_size (volume per bar) -- too small creates noisy bars, too large loses temporal resolution.

Key Takeaways

1. VPIN detects informed flow in real time -- confirmed on actual BTC perpetual trades.

2. High VPIN predicts high future volatility -- ~20% larger price moves in the top vs bottom VPIN-surprise quintile.

3. Volume bars > time bars for any microstructure analysis. Equal-time bars are an artefact of data storage, not market reality.

4. BVC is well-calibrated -- you don't need individual trade classification to get accurate buy/sell volume estimates.

5. Most of the time, markets are "normal" -- VPIN > 90th percentile is the danger zone.

Unlike OFI (which predicts direction), VPIN predicts volatility. A market maker uses both: OFI to lean their quotes, VPIN to set their spread width.

Next up: Microprice -- the volume-weighted fair value that's better than the mid.

This post is part of the HFT Secrets series -- 5 deep dives into the building blocks of high-frequency trading, each with real data from our crypto data lake.

For educational purposes only. Not investment advice.

Related Articles

• Building a Market-Maker on Hyperliquid — Part II: When Does It Work? — When market making works and when it doesn't

• Reference Guides - Order Book Dynamics — Queue dynamics, price formation, and microstructure

The Problem

You're watching a limit order book. The best bid is $87,250 with 2.5 BTC resting. The best ask is $87,251 with 0.3 BTC. A second later, the bid jumps to $87,251 with 1.8 BTC.

What just happened? And what does it tell you about where the price is going next?

Order Flow Imbalance (OFI) is the signal that answers this question. It decomposes every change in the top of the book into buying pressure and selling pressure, and produces a single number that predicts short-term price direction.

The Theory

Cont, Kukanov & Stoikov (2014) showed that OFI -- defined as the net change in limit order volume at the best bid and ask -- is the single strongest predictor of short-term price changes.

The intuition is simple. When a market participant wants to buy aggressively:

• They place new bids, increasing bid volume

• They lift asks, decreasing ask volume

• Both show up as positive OFI

The formula:

OFI_t = bid_contribution_t + ask_contribution_t

Where the bid contribution at time t is:

• If bid price rises: +bid_size(t) (new, higher bid = buying pressure)

• If bid price unchanged: bid_size(t) - bid_size(t-1) (net addition to existing bid)

• If bid price drops: -bid_size(t-1) (bid retreated = buying pressure withdrew)

And the ask contribution mirrors this logic on the sell side.

Real Data: BTC & ETH Perpetual Futures

We computed OFI from 5 days of Level 2 order book snapshots on Binance Futures (March 10-14, 2026). That's roughly 4 million snapshots per symbol at ~1 second resolution.

Here's what OFI looks like alongside price on a typical afternoon:

The cumulative OFI tracks price direction remarkably well. When buying pressure dominates (green), the price drifts up. When selling pressure takes over (red), the price drops.

Decomposition: Where Is the Pressure Coming From?

OFI is the sum of two components: bid-side pressure and ask-side pressure. Looking at them separately reveals which side of the book is driving price:

In this 30-minute window, you can see periods where both sides push in the same direction (strong moves) and periods where they diverge (choppy, uncertain markets). The net OFI (blue) is what you trade on.

Does It Predict Returns?

The key question: does OFI at time t predict the return from t to t+1?

The relationship is linear and statistically significant:

• BTC IC: 0.1376 -- small but extremely stable

• ETH IC: 0.1202 -- slightly weaker, consistent with lower BTC liquidity dominance

At 86,400 observations per day, even an IC of 0.01 produces a t-statistic above 3.0. This is not noise.

How Fast Does the Signal Decay?

If OFI predicts 1-second returns, does it also predict 10-second or 60-second returns?

The answer is clear: OFI is a fast signal. Predictive power peaks at 1-5 seconds and decays monotonically. By 60 seconds, most of the edge is gone. By 300 seconds, it's in the noise.

This is the hallmark of genuine microstructure alpha -- the information gets priced in quickly.

Is the Signal Stable?

A signal that works on average but flips randomly between positive and negative is useless. We measure stability by computing IC in rolling 5-minute windows:

The OFI signal is positive 98% of the time across 5-minute windows, with a mean IC of 0.1505. That's remarkably stable for a microstructure signal.

The Implementation

Here's the core OFI computation in Python -- the same code we used to generate the charts above:

def compute_ofi(bid_price, bid_size, ask_price, ask_size):
ofi = np.zeros(len(bid_price))

# Bid-side contribution
bp_up   = bid_price[1:] > bid_price[:-1]
bp_same = bid_price[1:] == bid_price[:-1]
bp_down = bid_price[1:] < bid_price[:-1]

ofi[1:] += np.where(bp_up,   bid_size[1:],
np.where(bp_same, bid_size[1:] - bid_size[:-1],
np.where(bp_down, -bid_size[:-1], 0.0)))

# Ask-side contribution
ap_up   = ask_price[1:] > ask_price[:-1]
ap_same = ask_price[1:] == ask_price[:-1]
ap_down = ask_price[1:] < ask_price[:-1]

ofi[1:] += np.where(ap_down, -ask_size[1:],
np.where(ap_same, -(ask_size[1:] - ask_size[:-1]),
np.where(ap_up,   ask_size[:-1], 0.0)))

return ofi

Complexity: O(n) time, O(n) space. No lookback windows, no parameters to tune. This is a purely mechanical decomposition of the order book.

Key Takeaways

1. OFI is the strongest single predictor of short-term price changes -- confirmed on real BTC and ETH perpetual data.

2. The signal is fast -- peak IC at 1-5 seconds, negligible by 60 seconds.

3. It decomposes cleanly into bid and ask contributions, letting you see which side of the book is driving the move.

4. It's stable -- positive IC in 98% of 5-minute windows.

5. It's simple -- O(n), no parameters, pure order book mechanics.

The catch? To exploit a signal that decays in 5 seconds, you need sub-second execution infrastructure. This is why OFI is the bread and butter of HFT firms, not retail traders.

Next up: VPIN -- detecting toxic flow before the big move happens.

This post is part of the HFT Secrets series -- 5 deep dives into the building blocks of high-frequency trading, each with real data from our crypto data lake.

For educational purposes only. Not investment advice.

Related Articles

• Reference Guides - Order Book Dynamics — Queue dynamics, price formation, and microstructure

• Crypto Orderflow Alpha Report — Feb 2026 — Order book signals and microstructure, February 2026

Six years of E-mini S&P 500 futures, 5-minute bar data, every major US economic release. What actually happens — and what's tradeable?

Every month, a handful of numbers move billions of dollars. CPI, NFP, FOMC decisions — traders know these acronyms matter, but few have quantified exactly how much. I built an event study on 6 years of ES 5-minute futures data (2020–early 2026) to answer the questions that matter: How big is the move? Does it stick? And can you trade it?

The Impact Hierarchy

Not all releases are created equal. The chart below ranks every major US economic release by its average absolute price move in the first 15 minutes after the number drops.

Three tiers emerge clearly:

• Tier 1 (25+ bps): FOMC, CPI, and NFP dominate. These are the market-moving events. FOMC decisions average 35 bps — that's roughly 17 ES points of initial movement.

• Tier 2 (15–25 bps): Fed Chair speeches, PCE, and PPI. Important but more manageable. PCE matters because it's the Fed's preferred inflation gauge.

• Tier 3 (8–15 bps): GDP, ISM, Retail Sales, sentiment surveys. Worth monitoring but rarely tradeable on their own.

Volume tells a similar story. FOMC and NFP see trading activity spike 5x above normal — the entire market is watching:

The Whipsaw Problem

Here's where it gets interesting. The biggest events are also the most dangerous. FOMC decisions reverse their initial move 72% of the time. Fed Chair speeches reverse 65%. If you're chasing the first move on an FOMC day, you're on the wrong side of the trade more often than not.

This isn't random — it reflects the mechanics of these events. FOMC decisions are followed by a press conference where Powell's Q&A can completely reframe the initial statement. The market reacts to the headline, then reacts again to the nuance. Same with speeches: key statements arrive at unpredictable moments, and the market lurches between interpretations.

The Core Insight: Data Continues, Speeches Reverse

The single most important finding in this analysis:

Hard economic numbers (CPI, ISM, GDP, PPI) produce persistent repricing. The market sees the number, processes it, and the move holds. These are momentum-friendly events.

Fed speeches and decisions produce whipsaw. Verbal guidance gets reinterpreted, and the initial move is noise. These are fade-friendly events — but only after the dust settles.

The continuation chart below breaks this down by individual release type. Above the line = momentum works. Below = fade works:

ISM Manufacturing and CPI lead the pack at 58% continuation. Fed Chair speeches sit at the bottom with just 40%. This is actionable: trade CPI with momentum, trade FOMC with patience.

How Long Does the Chaos Last?

Every announcement creates a volatility spike. The question is how fast it normalises. The chart below shows the "half-life" — how many minutes until volatility drops to 50% of the initial burst:

FOMC decisions keep the market rattled for ~40 minutes. Jobless Claims? About 10 minutes. This matters for stop placement: you need wider stops during FOMC's volatility window and can run tighter stops after ISM.

Under the Hood: What the Data Really Looks Like

Averages are useful, but they hide the variance. This violin plot shows the full distribution of initial moves for the six most impactful events:

FOMC's distribution is the widest — some decisions barely move the needle, while others produce 80+ bps of immediate displacement. CPI is also wide but more consistently large. ISM Manufacturing has the tightest distribution: modest but reliable.

Average Price Path After Major Events

The chart below shows the average absolute price path from 60 minutes before to 4 hours after each major release. The release moment is marked by the dashed line:

A few things jump out: pre-announcement compression is real (prices flatten before the release), and FOMC/CPI produce the largest and most sustained displacements. The bands show standard deviation — wider bands mean less predictable paths.

FOMC: The Whipsaw in Action

To illustrate the whipsaw problem concretely, here are individual FOMC price paths overlaid. Each faint red line is one meeting. The yellow line is the average:

The spaghetti of paths going in every direction after T=0 shows why the first 15 minutes of FOMC are essentially untradeable. The average converges to near-zero because up-moves and down-moves cancel out — but each individual path is violent.

The Full Picture

This heatmap compresses all the key metrics into one view. Darker cells = higher relative values:

And the four-panel overview that puts impact, volume, whipsaw, and continuation side by side:

CPI: A Closer Look

CPI is the best event for directional trading, so it deserves its own deep dive. Every CPI release since 2020, plotted individually:

The top panel shows signed moves — green bars for rallies, red for selloffs. The bottom shows absolute magnitude with a rolling average. The 2022 CPI prints (during peak inflation uncertainty) were monsters. More recently, moves have moderated but remain significant.

Has Announcement Impact Changed Over Time?

2022 stands out — the year the Fed launched its aggressive hiking cycle. Every economic release was being read through the lens of "what does this mean for rate policy?" That elevated the impact of all data. As the cycle has matured, impact has normalised but remains above pre-2022 levels.

The Event-Specific Playbook

Based on all of this analysis, here are the concrete rules for each release:

FOMC Decision: Do NOT chase the initial move. 72% whipsaw rate. Wait 15–30 minutes for the press conference to play out. The real move often starts during Q&A, not the statement release.

CPI: The best momentum trade. 58% continuation, lowest whipsaw among Tier 1 events. If you're going to chase one event, this is it. The 15-minute direction tends to hold into the close.

NFP: Wait for the 8:45 ET retest. Initial spike is noisy (58% whipsaw), but the market often retests the pre-release level within the first 15 minutes. Trade the direction of the second move.

PPI: A setup for CPI. PPI often drops 1-2 days before CPI and sets the tone. 55% continuation, moderate impact. Trade initial direction with pre-release level as your stop.

PCE: The Fed's preferred gauge. Similar character to CPI but lower magnitude. Only worth trading if the initial move exceeds 20 bps in the first 5 minutes.

ISM Manufacturing: Underrated. Released at 10 AM into a liquid market (unlike pre-open data drops). Best continuation rate tied with CPI at 58%. Trade tight stops. Moves above/below the 50 level generate outsized reactions.

Fed Speeches: Wait for the full speech. 65% whipsaw. Unless the market is already on edge about rates, most speeches are noise.

Jobless Claims: Ignore unless the deviation is massive (>20K miss). Weekly release, low signal-to-noise, usually overshadowed by same-morning releases.

Five Rules to Trade By

1. Never chase FOMC or Fed speeches. Whipsaw rates exceed 65%. Let 15-30 minutes pass.

2. CPI is your best momentum bet. 58% continuation, and the direction at T+15min tends to persist.

3. Hard numbers persist, interpretive language reverses. This is the single most important pattern in event trading.

4. Widen your stops during the volatility window. 40 minutes for FOMC, 15 minutes for ISM. Don't get stopped out by noise.

5. Without a specific edge, your expected P&L is negative after costs. Event trading is not free alpha — it requires discipline and selectivity.

Analysis based on ES E-mini S&P 500 5-minute bar data, January 2020 through early 2026. ~500+ events across 13 release types. All metrics computed on 15-minute and 60-minute observation windows. Past patterns do not guarantee future behaviour. Not financial advice.

Related Articles

• How my hyperliquid vault trades: Multi-Horizon Systematic Trading — How our Hyperliquid vault combines multi-timeframe systematic signals

• Crypto - Price Action Alpha Report - Jan 2026 — Data-driven analysis of cryptocurrency price patterns

• 5 Signal Scaling Tricks That Turn Model Predictions Into Actual Trades — From raw prediction to optimal position sizing

Each drill includes the problem statement, the key insight, and a working Python implementation.

1. Order Flow Imbalance (OFI)

The drill: Compute OFI from L1 order book snapshots (best bid/ask price & size).

Why it matters: OFI, introduced by Cont, Kukanov & Stoikov (2014), captures supply/demand shifts at the top of book. When the bid queue grows or the ask queue shrinks, buying pressure increases. A simple linear regression of price changes on OFI explains 40-65% of short-term price variance — making it one of the most powerful microstructure signals in production systems.

The key insight is tracking changes in queue sizes, conditioned on whether the price level itself moved.

OFI(t) = ΔBid(t) − ΔAsk(t)

where ΔBid = Qbid · 1{Pbid ↑} + (Qbid − Qbid,prev) · 1{Pbid =} − Qbid,prev · 1{Pbid ↓}

ΔP = β · OFI + ε (R² ≈ 0.40–0.65 at 10s horizons)

import numpy as np, pandas as pd

def compute_ofi(ob: pd.DataFrame) -> pd.Series:
    """ob must have columns: bid_price, bid_size, ask_price, ask_size"""
    bp, bs = ob['bid_price'], ob['bid_size']
    ap, asize = ob['ask_price'], ob['ask_size']

    # Bid side contribution
    bid_up   = (bp > bp.shift(1)).astype(int)
    bid_same = (bp == bp.shift(1)).astype(int)
    bid_dn   = (bp < bp.shift(1)).astype(int)
    ofi_bid  = bid_up * bs + bid_same * (bs - bs.shift(1)) - bid_dn * bs.shift(1)

    # Ask side contribution
    ask_dn   = (ap < ap.shift(1)).astype(int)
    ask_same = (ap == ap.shift(1)).astype(int)
    ask_up   = (ap > ap.shift(1)).astype(int)
    ofi_ask  = ask_dn * asize + ask_same * (asize - asize.shift(1)) - ask_up * asize.shift(1)

    return ofi_bid - ofi_ask  # positive = net buying pressure

O(n) time · O(1) space per tick

2. VPIN — Volume-Synchronized Probability of Informed Trading

The drill: Implement VPIN using Bulk Volume Classification on trade data.

Why it matters: VPIN (Easley, Lopez de Prado, O'Hara 2012) answers a critical question: is the flow hitting my quotes informed or noise? It groups trades into equal-volume buckets (volume-time instead of clock-time) and measures how one-sided each bucket is. VPIN spiked dramatically before the 2010 Flash Crash — it's now a standard toxicity metric for market makers deciding whether to widen spreads or pull quotes entirely.

VPIN = (1/n) · ∑τ=1..n |Vbuy(τ) − Vsell(τ)| / Vbucket

Vbuy = V · Φ(ΔP / σ)  Vsell = V · (1 − Φ(ΔP / σ))

where Φ is the standard normal CDF (Bulk Volume Classification)

import numpy as np
from scipy.stats import norm

def compute_vpin(prices, volumes, bucket_size, n_buckets=50):
    """
    prices, volumes: arrays of trade prices and quantities.
    bucket_size: volume per bucket (e.g. daily_vol / 50).
    """
    # BVC: classify each trade's volume as buy or sell
    dp = np.diff(prices, prepend=prices[0])
    sigma = np.std(dp[dp != 0]) or 1e-10
    buy_pct = norm.cdf(dp / sigma)
    buy_vol = volumes * buy_pct
    sell_vol = volumes * (1 - buy_pct)

    # Accumulate into equal-volume buckets
    cum_vol = np.cumsum(volumes)
    bucket_ids = (cum_vol // bucket_size).astype(int)

    imbalances = []
    for b in range(bucket_ids[-1] + 1):
        mask = bucket_ids == b
        bv = buy_vol[mask].sum()
        sv = sell_vol[mask].sum()
        imbalances.append(abs(bv - sv))

    imb = np.array(imbalances)
    # Rolling VPIN over n_buckets
    if len(imb) < n_buckets:
        return np.array([imb.sum() / (bucket_size * len(imb))])
    vpin = np.convolve(imb, np.ones(n_buckets), 'valid') / (n_buckets * bucket_size)
    return vpin

# VPIN near 0 = balanced flow; near 1 = highly toxic

O(n) time · O(B) space where B = num buckets

3. Microprice

The drill: Compute the microprice from L1 order book data.

Why it matters: The midprice treats bid and ask equally, but that's wrong when queue sizes differ. Stoikov (2018) showed that the microprice — which weights each side by the opposite side's depth — is a better short-term price predictor because it incorporates queue imbalance. If bid size is much larger than ask size, the microprice sits above the mid, correctly predicting upward pressure. It's a martingale by construction and the simplest meaningful upgrade over the midprice.

Pmicro = Pask · Qbid / (Qbid + Qask) + Pbid · Qask / (Qbid + Qask)

Pmicro − Pmid = spread · (imbalance − 0.5)

where imbalance = Qbid / (Qbid + Qask)

import pandas as pd

def microprice(bid_price, ask_price, bid_size, ask_size):
    """Vectorized microprice computation."""
    total = bid_size + ask_size
    return (bid_size * ask_price + ask_size * bid_price) / total

def microprice_signal(ob: pd.DataFrame, lag: int = 1) -> pd.Series:
    """Microprice return as a signal."""
    mp = microprice(ob['bid_price'], ob['ask_price'],
                    ob['bid_size'], ob['ask_size'])
    return mp.pct_change(lag)

# micro vs mid: micro adjusts for imbalance
# If bid_size >> ask_size, micro > mid (predicts price going up)
# Difference: micro - mid = spread * (imbalance - 0.5)

O(1) per tick · O(n) vectorized

4. Avellaneda-Stoikov Optimal Quotes

The drill: Compute optimal bid/ask quotes using the Avellaneda-Stoikov model.

Why it matters: This is the foundational market making model. Avellaneda & Stoikov (2008) solved the problem of where to place your bid and ask quotes given your current inventory, the asset's volatility, and how much time remains in the trading session. The key idea: your reservation price (where you'd trade at fair value) shifts away from mid in proportion to your inventory. When you're long, you lower your ask to encourage selling. The optimal spread depends on volatility, risk aversion, and order arrival intensity.

r(t) = S(t) − q · γ · σ² · (T − t)

δ = γ · σ² · (T − t) + (2/γ) · ln(1 + γ/k)

bid = r − δ/2  ask = r + δ/2

where q = inventory, γ = risk aversion, k = order arrival intensity

import numpy as np

def avellaneda_stoikov(mid, inventory, sigma, gamma, k, T_rem):
    reservation = mid - inventory * gamma * sigma**2 * T_rem
    spread = gamma * sigma**2 * T_rem + (2/gamma) * np.log(1 + gamma/k)
    bid = reservation - spread / 2
    ask = reservation + spread / 2
    return {'bid': bid, 'ask': ask, 'reservation': reservation,
            'spread': ask - bid, 'skew': mid - reservation}

O(1) time · O(1) space

5. SPSC Lock-Free Ring Buffer

The drill: Implement a single-producer single-consumer lock-free ring buffer.

Why it matters: Every HFT system needs to pass market data from a feed handler to a strategy engine with minimal latency. The SPSC ring buffer is the fundamental IPC primitive that makes this possible — zero locks, zero allocations, deterministic latency. The producer writes at the tail, the consumer reads at the head, and neither ever waits for the other. In C++, this runs at 2-5 nanoseconds per operation (1B+ ops/sec). The critical optimization is cache-line padding between head and tail to prevent false sharing.

class SPSCRingBuffer:
    """Lock-free SPSC ring buffer (Python simulation of C++ pattern)."""
    def __init__(self, capacity=1024):
        self.capacity = capacity
        self.buffer = [None] * capacity
        self.head = 0  # consumer reads here
        self.tail = 0  # producer writes here
        # In C++: head/tail would be std::atomic<size_t>
        # with cache line padding (64 bytes) between them

    def push(self, item) -> bool:
        """Producer only. Returns False if full."""
        next_tail = (self.tail + 1) % self.capacity
        if next_tail == self.head:  # full
            return False
        self.buffer[self.tail] = item
        # In C++: self.tail.store(next_tail, memory_order_release)
        self.tail = next_tail
        return True

    def pop(self):
        """Consumer only. Returns None if empty."""
        if self.head == self.tail:  # empty
            return None
        item = self.buffer[self.head]
        # In C++: self.head.store(next, memory_order_release)
        self.head = (self.head + 1) % self.capacity
        return item

# C++ version: ~2-5ns per push/pop (1B+ ops/sec)
# Key: cache line padding between head and tail (64 bytes)
# struct alignas(64) { atomic<size_t> head; };
# struct alignas(64) { atomic<size_t> tail; };

O(1) push/pop · zero locks · zero allocations

These five drills span the full HFT stack — from reading the order book (OFI, Microprice), to detecting when to pull quotes (VPIN), to setting optimal prices (Avellaneda-Stoikov), to building the infrastructure that delivers data in nanoseconds (SPSC buffer). Master these and you'll have a solid foundation for any quant trading interview or system design discussion.

This post is part of the Quant Trading Drill Series — 150 hands-on coding exercises covering microstructure, statistical testing, market making, ML for alpha, and HFT systems.

Related Articles

• Building a Market-Maker on Hyperliquid — Part III: The Backtester — Building and backtesting a crypto market-making engine

• Crypto Orderflow Alpha Report — Feb 2026 — Decoding crypto market microstructure through order flow

• Building a Production-Grade Data Streamer for Hyperliquid — Building a real-time WebSocket data pipeline for crypto trading

The Four Quantum IPOs

IonQ (IONQ) — listed Oct 2021 via SPAC (dMY Technology III). $2B valuation, $636M proceeds, $350M PIPE from Fidelity, Silver Lake, Breakthrough Energy. Opened ~$10.60.

Rigetti (RGTI) — listed Mar 2022 via SPAC (Supernova Partners II). $1.5B valuation, $262M proceeds, $147.5M PIPE. Opened ~$9.75.

D-Wave (QBTS) — listed Aug 2022 via SPAC (DPCM Capital). $1.6B valuation, but 97% of the trust was redeemed — D-Wave received only $9M of a planned $300M. Opened ~$9.

Quantum Computing Inc (QUBT) — reverse shell acquisition of a defunct beverage company in 2018. Uplisted to Nasdaq Jul 2021. No institutional backing. The odd one out.

The Crash: Four for Four

IONQ: ~$10.60 → $3.04 (Dec 2022) — −71%* in ~15 months
RGTI: ~$9.75 → $0.36 (May 2023) — −96% in ~14 months
QBTS: ~$9.00 → $0.40 (May 2023) — −96% in ~9 months
QUBT: ~$6–8 → sub-$1 (~2023) — −85%+ in ~18 months

*IONQ hit $31 in its first month from retail hype — from that high, −90%.

The bottoms clustered within a five-month window (Dec 2022 to May 2023). Three different listing dates. Three different SPAC structures. One shared destination. The drivers: SPAC lock-up expiries triggering ~$926M in insider selling across the four names, dilution from cash-starved companies, the 2022 rate hiking cycle, and the reality check of quarterly earnings.

The Recovery: Multi-Thousand Percent

IONQ: $3.04 → $84.64 (+2,700%)
RGTI: $0.36 → $58.15 (+16,000%)
QBTS: $0.40 → $46.75 (+11,500%)
QUBT: sub-$1 → $25.84 (+2,500%+)

The post-IPO crash did not reflect the terminal value of these companies. It reflected the mechanics of SPACs, insider selling, and macro timing.

Why Quantinuum Is Different

All four existing quantum stocks went public via SPACs or reverse shells. Quantinuum is filing a traditional S-1 with Morgan Stanley and JPMorgan. No trust redemptions, no sponsor promotes, no SPAC arb desks. Honeywell retains ~54% ownership with no near-term exit need.

The fundamentals gap is enormous:

Revenue (at IPO): IONQ ~$2M | RGTI ~$8M | QBTS ~$7M | Quantinuum ~$115M (est.)
Valuation: IONQ $2B | RGTI $1.5B | QBTS $1.6B | Quantinuum ~$20B+
Employees: IONQ ~100 | RGTI ~144 | QBTS ~180 | Quantinuum 600+
Quantum Volume: IONQ 32 qubits* | RGTI N/A | QBTS N/A | Quantinuum 33.5 million
2-Qubit Gate Fidelity: IONQ ~97% | RGTI ~99% | QBTS N/A | Quantinuum 99.9%
Backing: all SPACs | Honeywell (54%), $1.2B+ raised, Traditional S-1

*IonQ had a 32-qubit system. IonQ claimed QV of 4 million (disputed). Quantinuum’s H2 achieved a verified QV of 2^25 = 33.5 million.

At the time of their IPOs, IonQ, Rigetti, and D-Wave had a combined $17M in revenue. Quantinuum is listing with an estimated ~$115M (the exact figure will be disclosed in the S-1) — a fundamentally different starting point. That said, the gap has narrowed: IonQ alone now guides for ~$108M in FY2025 revenue. The comparison that matters is at listing, where Quantinuum enters with 7x the revenue its peers had when they went public. Microsoft used the H2 to create logical qubits running 14,000 experiments with zero errors. This is not vaporware.

These differences should moderate the post-IPO decline. But they won’t eliminate it.

The Playbook

1. Don’t buy the open. In every quantum listing, buying day one was a losing trade for at least 6–12 months. Even with a better IPO structure, the pattern of post-IPO fades in large tech IPOs is strong.

2. Watch the lock-up expiry. Traditional IPOs typically impose 90–180 day lock-ups on pre-IPO shareholders. When insiders become eligible to sell, it creates a supply overhang. The terms will be in the prospectus — mark the date on your calendar.

3. Use the 20-day moving average. Long above it, flat below it. This filter had Sharpe 2.07 across the existing quantum names.

4. Buy crash reversals. When any quantum stock drops 20%+ in 1–3 days, it bounces 66–82% of the time. This is driven by market microstructure and retail panic, not company-specific factors — it should generalize to Quantinuum from day one.

5. Watch the sector. Quantinuum’s IPO will bring new capital and attention. If it succeeds, the IONQ/RGTI/QBTS/QUBT complex rallies in sympathy. If it fails, they get dragged down.

The Bottom Line

Every quantum stock has crashed 90%+ from its highs post-IPO, then recovered thousands of percent. Quantinuum is structurally different — traditional IPO, Honeywell anchor, 10x revenue, best hardware. The most likely outcome is a 30–50% fade over 3–6 months before finding a floor.

The optimal strategy: don’t buy the open, wait for the fade, apply the 20-day moving average filter, and buy the crash reversals when they come. Patience has been the single most profitable edge in quantum stocks. Quantinuum won’t be different.

Follow-up to “I Backtested 37 Strategies on Every Quantum Computing Stock (2017–2024)” Quantinuum IPO information based on public filings and Honeywell press releases. S-1 filed confidentially January 14, 2026. No date, price range, or share count disclosed. This is not financial advice.

Related Articles

• I Backtested 37 Strategies on Every Quantum Computing Stock (2017–2024) — 37 strategies backtested on quantum computing stocks

Quantum computing stocks are the most volatile corner of the US equity market. Daily standard deviations of 500–3,500 basis points. Kurtosis values up to 27. Single-day moves that would take the S&P 500 a year to produce.

Everyone has an opinion on these names. Few have data.

I ran an exhaustive pattern analysis across four publicly traded quantum computing companies — IonQ (IONQ), Quantum Computing Inc (QUBT), Rigetti (RGTI), and D-Wave (QBTS) — on daily bars from each stock’s listing through end of 2025. QUBT has data back to mid-2018. IONQ from 2021. RGTI and QBTS from 2022. The stocks have lived through radically different market regimes, and the patterns have evolved accordingly.

Here’s what I found.

Finding 1: IONQ Led the Sector — In 2024. Not Before, Not After.

IONQ’s daily return predicts next-day returns in QUBT and QBTS — but only in certain years. When I break the lead-lag correlation down year by year, a different picture emerges from the aggregate statistics.

IONQ → QUBT next-day correlation, by year:

• 2021: r = 0.051, p = 0.423 — noise

• 2022: r = 0.094, p = 0.136 — noise

• 2023: r = 0.088, p = 0.163 — noise

• 2024: r = 0.250, p = 0.0001 — 3x stronger than any prior year

• 2025: r = 0.001, p = 0.988 — completely gone

The contagion effect tells the same story. When IONQ had a top-10% up day, what happened to QUBT the next day?

• 2021: +175 basis points next day, 44% hit rate

• 2022: −22 basis points, 46% hit rate

• 2023: +103 basis points, 44% hit rate

• 2024: +1,102 basis points, 65% hit rate — extraordinary

• 2025: −19 basis points, 44% hit rate — back to noise

In 2024, when IONQ had a top-10% up day, QUBT averaged +1,102 basis points the next day with a 65% hit rate. That’s an extraordinary signal. But it was a product of the 2024 quantum mania — when the entire sector went parabolic and retail attention was at peak. In 2025, the daily close-to-close effect has essentially disappeared.

The aggregate statistics across all years (r=0.108, p=0.0001 across 1,252 observations) are real — but they’re driven almost entirely by one year. This is important context for anyone trying to trade this signal going forward.

That said, the daily picture may not be the whole story. On some of the larger IONQ move days in 2025, anecdotal observation suggests the spillover into QUBT and QBTS still happens — just faster. This is a common pattern in market microstructure: as more participants discover a lead-lag relationship, the effect doesn’t disappear entirely — it compresses in time. What used to take a full trading day to transmit may now play out within hours or even minutes. The daily correlation reads zero because by the close, the move has already been priced in. A proper intraday analysis at 5-minute or 30-minute resolution would be needed to confirm this — and that will be the subject of a future post.

Lesson: The IONQ lead-lag was a regime-specific effect on daily bars, not a permanent feature. It worked spectacularly in 2024’s blow-off rally. It was noise in 2021–2023 and has vanished from the daily data in 2025. The effect may have migrated to intraday timeframes as market efficiency increased — but on a close-to-close basis, it’s gone.

Finding 2: Systematic Mean Reversion Is Dead — But Crashes Still Revert

I tested Bollinger Band mean reversion and z-score reversion at multiple lookbacks. On the aggregate data, every systematic mean-reversion strategy loses money. But the year-by-year picture reveals that mean reversion was profitable in the early years and then died — with one important exception.

QUBT — the stock I identified as “the only mean-reverter” — shows this evolution most clearly. Its Bollinger Band (20-day window) predictive strength over the next 10 trading days, by year:

• 2019: +0.636 — extreme mean reversion, one of the strongest single-stock signals I’ve ever measured

• 2020: +0.185 — moderate mean reversion

• 2021: +0.318 — strong mean reversion

• 2022: +0.040 — weak, basically noise

• 2023: +0.223 — moderate mean reversion

• 2024: −0.098 — flipped to momentum

• 2025: −0.101 — still momentum

From 2019 to 2023, QUBT reliably mean-reverted. But in 2024, the sign flipped. QUBT stopped reverting and started trending — just like the other three stocks always had.

The portfolio-level Bollinger Band mean-reversion strategy tells the same story: Sharpe +2.68 in 2018, −1.50 in 2020, +0.38 in 2022, −0.86 in 2024, −0.44 in 2025. Z-score mean reversion at 20-day lookback follows the same pattern: Sharpe +4.71 in 2019 (when QUBT was a strong mean-reverter), then −1.32 in 2022, −2.13 in 2024. Mean reversion worked when these stocks were obscure, illiquid, and ignored. Once institutional attention arrived and the sector became a momentum vehicle, systematic mean reversion turned into a money pit.

But one form of mean reversion survives: extreme crash reversals.

I tested every combination of: stock × lookback (1–60 days) × drop threshold (3%–20%) × forward horizon (1–40 days). That’s roughly 2,000 conditions per stock. When a quantum stock drops more than 20% over 1–3 days, it bounces 66–82% of the time:

• RGTI drops >20% over 2 days → bounces 82% of the time over 5 days, average +2,335 basis points (17 events)

• QUBT drops >20% in 1 day → bounces 72% next day, average +1,522 basis points (29 events)

• IONQ drops >20% over 3 days → bounces 70% over 10 days, average +1,524 basis points (20 events)

• QUBT drops >20% over 2 days → bounces 66% over 10 days, average +2,170 basis points (38 events)

• IONQ drops >7% in 1 day → bounces 63% next day, average +160 basis points (97 events)

The post-big-drop strategy (buy after a 5th-percentile down day) has Sharpe 0.91 with max drawdown of only −41K basis points — the lowest drawdown of any strategy tested.

Why does systematic mean reversion fail while crash reversals work? Because they operate at different scales. Bollinger Band and z-score strategies trade every oscillation — the small ones that, in a momentum market, aren’t actually reversions at all. They’re just pauses before continuation. Crash reversals, by contrast, only trigger on extreme overshoots — 20%+ drops in 1–3 days — which are violent enough to create genuine reversion even in a trending market. The crashes overshoot regardless of the regime.

Rule: Don’t trade systematic mean reversion on quantum stocks — it died when the sector went mainstream. But use crash reversals as a tactical overlay: when any stock drops >20% in 1–3 days, buy. Reversal rate: 66–82%. It fires too rarely to be a core strategy, but when it fires, it’s reliable — and it’s the only form of mean reversion that has worked across every regime in the data.

Finding 3: Trend-Following Works — But Only the Long Side

If systematic mean reversion is dead, does trend-following work? I tested two families of strategies. The first is a simple moving average filter: if today’s closing price is above the N-day moving average, go long; if below, go short. The second is a breakout strategy: go long when the price closes above the N-day high, short when it closes below the N-day low. I tested both at 5, 20, and 120-day lookbacks, and split each into its long and short components.

The long side does all the work. Every short leg loses money.

Moving average strategies (long Sharpe / short Sharpe / long max drawdown):

• 120-Day Moving Average: long Sharpe 2.19, short −1.20, max drawdown −237K basis points

• 20-Day Moving Average: long Sharpe 2.07, short −1.06, max drawdown −228K basis points

• 5-Day Moving Average: long Sharpe 1.75, short −1.44, max drawdown −218K basis points

Breakout strategies:

• 5-Day Breakout: long Sharpe 1.43, short −0.93, max drawdown −84K basis points

• 20-Day Breakout: long Sharpe 1.33, short −0.49, max drawdown −59K basis points

• 120-Day Breakout: long Sharpe 1.16, short −0.47, max drawdown −50K basis points

But here’s the catch — year by year, the pattern is not uniform. Looking at the 20-day moving average strategy (Sharpe, portfolio-level):

• 2021: Buy & hold Sharpe +0.12, long +0.46, short +0.35 — flat year, modest results across the board

• 2022: Buy & hold −2.27, long −0.41, short +2.25 — the standout year for shorting

• 2023: Buy & hold +0.88, long +0.49, short −0.98 — recovery begins

• 2024: Buy & hold +3.00, long +3.01, short −0.77 — blow-off rally

• 2025: Buy & hold +0.86, long +0.14, short −1.15 — continuation

2022 was the standout year for shorting — the 20-day moving average short had Sharpe +2.25 as the sector crashed. In 2023–2025, the short side is consistently negative. This means the combined long/short strategies are essentially dragging a profitable long side through the mud of a losing short side, except during crash years.

The trend long-only Sharpe tracks the overall market environment: slightly negative in 2022’s crash, modest in 2023’s recovery, explosive in 2024’s rally, muted in 2025. It doesn’t predict — it participates. And by going flat instead of short during bear periods, it avoids the worst drawdowns.

Rule: Use the 20-day moving average long-only as your primary filter. When price is above the 20-day moving average, be long. When below, go flat — never short. The long side has Sharpe 2.07 overall with max drawdown −228K (vs −626K for buy-and-hold). Shorting worked in 2022’s crash but has been reliably destructive since.

Finding 4: How These Stocks Evolved — A Regime Map

The most important thing I learned from this analysis is that quantum stocks have changed character over time. No single year looks like any other.

2018–2020 (QUBT only). Buy & hold Sharpe: 1.2–1.8. What worked: mean reversion (signal strength 0.64 in 2019), buy-and-hold. What failed: trend-following (too illiquid).

2021 (IONQ, QUBT, RGTI join). Buy & hold Sharpe: +0.12. What worked: mean reversion (Bollinger Band Sharpe +2.68 in 2018–2019 era). What failed: everything else — it was a flat year.

2022 (all four stocks). Buy & hold Sharpe: −2.27. What worked: shorting (Sharpe +2.25) — the standout year. What failed: buy-and-hold, trend long.

2023 (all four). Buy & hold Sharpe: +0.88. What worked: trend long (modest). What failed: mean reversion (breaking down).

2024 (all four). Buy & hold Sharpe: +3.00. What worked: trend long (Sharpe +3.01), IONQ lead-lag. What failed: mean reversion (Sharpe −0.86), shorting.

2025 (all four). Buy & hold Sharpe: +0.86. What worked: trend long (+0.14, barely). What failed: mean reversion (−0.44), IONQ lead-lag (gone), shorting (−1.15).

The story arc is clear:

2018–2021: The Mean Reversion Era. When QUBT was the only name and the sector was unknown, stocks overreacted and corrected. QUBT’s Bollinger Band signal strength of 0.636 in 2019 (measured over 10-day forward returns) is one of the strongest single-stock signals I’ve ever measured. Mean reversion was the dominant regime. Volatility was high (QUBT daily standard deviation: 3,551 basis points in 2018) but the market was small and inefficient.

2022: The Crash. The sector lost massively. Buy-and-hold Sharpe: −2.27. This was the standout year for shorting (20-day moving average short Sharpe: +2.25). Mean reversion started breaking down. Volatility moderated as the stocks matured.

2023: The Transition. Returns came back, but the character had shifted. Mean reversion no longer worked reliably. Momentum signal strength was near zero. This was the transition year between the old regime (mean reversion works) and the new one (trend dominates).

2024: The Blow-Off. Everything changed. Buy-and-hold Sharpe: +3.00. IONQ’s lead-lag surged to r=0.250. Systematic mean reversion was catastrophic (Sharpe −0.86 to −2.13). Trend long-only delivered Sharpe +3.01. This was a momentum mania driven by AI/quantum hype and retail inflows.

2025: The New Normal? Returns moderated but stayed positive (buy-and-hold Sharpe +0.86). Trend long-only barely positive (+0.14). The IONQ lead-lag signal vanished completely (r=0.001). Mean reversion remains negative. The sector has cooled from the 2024 mania, but hasn’t returned to its pre-2024 character.

Lesson: Any analysis of quantum stocks that presents one set of statistics across the full period is misleading. The market has gone through at least three distinct regimes. What worked in 2019–2021 (mean reversion) is now catastrophic. What works in 2024 (trend long-only) barely registered in 2025. The only constant: crash reversals work in every regime.

The Bottom Line

These stocks have evolved from mean-reverting oddities to momentum vehicles. The regime keeps changing, and the strategies that work change with it. Three things survive: go long above the 20-day moving average and flat below it, buy crashes over 20%, and never short.

Analysis performed using daily bars from mid-2018 through December 2025 — 4,737 stock-days across four symbols. QUBT: Jul 2018–Dec 2025. IONQ: Jan 2021–Dec 2025. RGTI: Mar 2022–Dec 2025. QBTS: Aug 2022–Dec 2025. Bollinger Bands tested at 10 windows (5–120 days). Z-score reversion tested at 7 lookbacks (1–120 days). Moving average crossover and breakout trend-following at 3 horizons, decomposed into long-only and short-only. Conditional reversals tested at 6 thresholds × 8 lookbacks × 5 forward horizons per stock. 37 strategies backtested. Year-by-year regime analysis across all key metrics.

This is not financial advice. Past performance does not guarantee future results. These are small-cap, high-volatility stocks with limited history. The regime shifts documented here underscore that future behavior may differ from any historical period.

Related Articles

• Every Quantum Stock Crashed 90%+ After Its IPO. Here’s What That Means for Quantinuum. — Quantinuum IPO analysis via quantum stock history

• Reference Guides - Regime Detection — HMM, change-point detection, and regime-aware trading

It isn’t. And the reasons why are more interesting than the trade itself.

I want to start with the thing that most discussions of crypto arb skip over entirely — the fungibility problem — because once you understand it, everything else clicks into place.

The Fungibility Problem

Here’s the thing nobody talks about: $1 of BTC on Binance is not the same thing as $1 of BTC on Coinbase. Not right now, not in any practical sense. You can’t instantly swap one for the other. And that breaks arbitrage at its root.

Think about how this works in stocks. AAPL trades at $190.00 on NYSE and $190.05 on NASDAQ. A market maker buys on NYSE, sells on NASDAQ, pockets the nickel. Why doesn’t fungibility kill this trade? Because NYSE and NASDAQ are just matching engines — they don’t hold the shares. All equity trades clear and settle through a single post-trade stack: NSCC nets the obligations, DTC holds the ownership record. Buy on NYSE, sell on NASDAQ, both trades flow into the same system. Shares are fungible by construction — not because stocks are special, but because the plumbing was built to make them that way.

Now here’s the ironic part: the blockchain is a shared ledger. BTC has exactly the kind of canonical record that makes fungibility work. But crypto exchanges don’t settle trades on that shared ledger — they settle internally, on their own private databases. Binance runs its own books. Coinbase runs its own books. The blockchain only gets involved when you withdraw. So the shared ledger exists, but it’s the slow, expensive escape hatch, not the settlement layer.

                    Equities              Crypto
Trades clear:      Centrally (NSCC)      Per-venue
Ownership:         One place (DTC)       Per exchange
Settlement:        Netted, T+1           Gross, slow, on-chain
Credit risk:       Mutualized            Isolated per exchange
Fungibility:       Immediate             Delayed and conditional

Traditional finance spent decades building plumbing to make this seamless — central clearing, prime brokers, delivery-versus-payment settlement. Crypto has none of it. There are companies working on it (Copper ClearLoop, Fireblocks, Ceffu) but even a perfect crypto prime broker wouldn’t fully solve the problem: on-chain settlement is slow and unpredictable, every exchange carries different credit risk (your balance is an unsecured loan to that exchange), and transfer times depend on gas, congestion, and the exchange’s mood. The tradfi analog? Imagine cross-venue equity arb, but DTCC doesn’t exist, your prime broker might go bankrupt (see: FTX), and moving shares takes 30 minutes on a good day. That’s crypto — permanently operating in what tradfi would consider a crisis regime.

So you’re left with two options: pre-position inventory on both sides (keep BTC and USD on every exchange, trade without moving anything), or actually transfer coins (buy here, send there, sell — way too slow for any spread that matters on major pairs). Everyone serious uses option 1.

Bottom line: Crypto has a shared ledger but doesn’t use it for settlement. Every exchange is its own silo. You can’t move value between them fast enough to arb efficiently — so you have to park capital on every venue and hope it doesn’t drift out of balance (or worse, that the exchange doesn’t go under with your money on it).

Spot Arbitrage

The simplest version of the trade. BTC is cheaper on one exchange, more expensive on another. Buy low, sell high.

Transfer-based: doesn’t work

Coinbase BTC:  $60,000
Binance BTC:   $60,120
Spread:        $120 (20 bps)

Buy on Coinbase, withdraw, deposit on Binance, sell. Easy, right?

Coinbase buy fee (0.10%):          -$60
Withdrawal fee (~0.0005 BTC):      -$30
Network fee:                        -$5
Binance sell fee (0.10%):          -$60
                                   -----
Total cost:                        ~$155
Spread:                             $120
Net:                                -$35

Oh, and this assumes the spread is still there when your BTC
arrives 30 minutes later. It won’t be.

For major pairs on major exchanges, transfer-based spot arb is dead. Maybe you can still find it on obscure tokens with big dislocations — if you trust the exchange to let you withdraw.

Inventory-based: possible, but harder than it looks

Keep BTC and stables on every exchange. When a spread appears, buy on the cheap side and sell on the expensive side simultaneously. No transfer needed.

You have:
  Coinbase:  0.5 BTC + $30,000 USDC
  Binance:   0.5 BTC + $30,000 USDT

Spread pops up: Coinbase $60,000 / Binance $60,080

Buy 0.1 BTC on Coinbase at $60,005 (ask)
Sell 0.1 BTC on Binance at $60,075 (bid)
Gross: $7.00

Fees:
  Coinbase taker (0.10%): $6.00
  Binance taker (0.04%):  $2.40
                          -----
Net: -$1.40

Still negative. You need 14+ bps of spread to break even at taker fees.
That exists maybe 2-5% of the time on BTC between major exchanges.

The firms that actually make money here aren’t paying taker fees — they’re collecting maker rebates at VIP tiers (Coinbase -0.02%, Binance -0.01%). At those rates you earn $1.80 in rebates on top of whatever spread you capture, and your break-even spread is basically zero. This is the dirty secret of spot arb: the profitable firms are running a market-making operation that happens to hedge cross-exchange. The “arb” is almost incidental to the rebate income.

Even then, there’s a slow bleed. If Coinbase is consistently the cheap exchange, all your BTC drifts there and all your dollars drift to Binance. Eventually you have to rebalance — send BTC one way, stables the other. That’s 30 minutes offline minimum, gas costs, and the whole time you can’t trade. Every arb backtest ignores this. In practice, rebalancing cost and downtime eat a real chunk of returns.

Spot arb in one sentence: Transfer-based is dead on major pairs (costs > spread). Inventory-based is negative at taker fees (need 14+ bps). The people making money are collecting maker rebates at VIP tiers — they’re market-making, not arbitraging.

Perp Spread Arbitrage

Same concept, different instrument. BTC-PERP trades at $60,020 on Binance and $60,080 on Bybit. Go long the cheap one, short the expensive one, wait for convergence. At least your margin stays on each exchange — no transfers needed. But you get a different set of problems.

Perps diverge across exchanges because the venues are genuinely different: different user bases and leverage appetites, different index compositions, different liquidation engines (a cascade on Binance doesn’t directly move Bybit), different funding intervals (Binance 8h, Hyperliquid 1h). These aren’t bugs — they’re structural features of fragmented markets.

The math

Binance BTC-PERP mid:  $60,020
Bybit BTC-PERP mid:    $60,080
Spread: 10 bps

Buy Binance, sell Bybit. Captured spread: $50 on 1 BTC.
Taker fees: 0.04% x $60k x 2 legs = $48
Net on entry: $2. Grand.

Now the spread converges to 0 and you close:
  Exit fees: another $48
  Round-trip total: $50 - $48 - $48 = -$46

You lost money on a trade where the spread moved in your favor.
You need 16+ bps to even break even. On BTC, between
major exchanges, in normal conditions? That’s rare.

The risks

On top of the fees problem, you’re holding opposite perp positions on two exchanges. No margin portability — spread widens, one leg bleeds margin while the other accumulates it, and you can’t move capital between exchanges fast enough to matter. Asymmetric liquidation — if the spread blows out far enough (50-100+ bps during cascades), one leg gets liquidated and you’re sitting on a naked directional position during a crash. Non-simultaneous exit — two APIs, two matching engines, public internet. In a fast market, the spread moves between your two fills.

And unlike spot spreads, which are loosely bounded by transfer costs, perp-perp spreads have no natural boundary. They gap violently during exchange-specific events — API outages, insurance fund depletion, flash crashes on one venue.

Perp arb in one sentence: You need 16+ bps just to break even at taker fees — and while you wait for convergence, you’re exposed to asymmetric liquidation across two exchanges that can’t talk to each other. The “hedged” position is two independent bets on two independent counterparties.

What’s Actually Behind These Price Differences

Not all spreads are created equal. Some you can trade. Some you can’t. Some aren’t even real.

Temporary dislocations — these mean-revert and are what arb traders hunt. A whale market-sells 500 BTC on Binance, pushing it down $50 vs other exchanges. News hits one exchange’s feed before another. A liquidation cascade on one venue drives its price away from the pack. These are real opportunities, but they require speed — the millisecond kind, not the “check the screen” kind.

Structural dislocations — these persist but usually can’t be arbed. The Kimchi premium (Korean exchanges trading 3-5% higher) requires Korean banking access. An exchange quoting in USDT vs actual USD — that’s a stablecoin bet, not a BTC arb. An exchange restricting withdrawals can diverge persistently because nobody can arb it.

Fake dislocations — your API data is 200ms stale, so you see a spread that’s already closed. The bid on exchange B is 0.1 BTC deep — meaningful for a toy position, not for real size. Exchange A shows a lower price but charges 0.10% while exchange B shows higher but charges 0.02%. After fees, there’s no spread. A lot of what looks like “arb” on aggregator dashboards falls into this bucket.

When It Actually Makes Money

The people who make this work treat it as an infrastructure business, not a trade.

Maker rebates are the actual product. At VIP tiers you earn 1-2 bps per fill instead of paying 4. The arb logic is your hedging strategy. Most profitable cross-exchange desks are really running distributed market-making.

Speed is table stakes. Co-located servers, dedicated connections, single-digit millisecond execution. If you’re running this from a home connection through the REST API, you’re seeing ghosts — the spread is gone by the time your order hits.

Inventory management is the hard part. Automated rebalancing across chains (Tron for USDT, Solana for USDC, Ethereum as fallback). Quoting algorithms that skew prices to naturally rebalance — heavy BTC on Coinbase? Quote your Coinbase asks more aggressively.

One pair won’t do it. Run 10-20 liquid pairs across 3-5 exchanges. Any single pair is thin and noisy. In portfolio, the returns smooth out.

Risk limits that actually trigger. Max inventory per exchange under 15% of capital. Auto-flatten if an exchange starts acting weird. If you don’t automate this, you’ll learn why you should have during the next exchange-specific event.

Scale or don’t bother. Infra costs six figures a year. At $100k capital, you can’t cover costs. At $5M+, thin margins start compounding to real numbers.

Under all these conditions, net returns land around 10-30% annualized with Sharpe ratios of 3-6. But it’s a technology business that happens to express itself through trading, not a “strategy” you run from a laptop.

So What’s the Spread Actually Telling You?

When you see BTC at $60,020 on one exchange and $60,080 on another, you’re not looking at free money. You’re looking at a price — the market-clearing price of settlement risk, counterparty risk, and execution latency.

That $60 gap is what it costs the market to not have a shared settlement layer. Someone with the right infrastructure, fee tier, and speed can capture a portion of it. For everyone else, it’s a number on a screen that looks a lot more capturable than it is.

Disclaimer: Educational content, not financial advice. Crypto trading involves substantial risk of loss. Cross-exchange strategies carry counterparty, settlement, and execution risks. Past returns don’t guarantee future results.

Related Articles

• Building a Production-Grade Data Streamer for Hyperliquid — Real-time WebSocket data pipeline for Hyperliquid

• Building a Market-Maker on Hyperliquid — Part I: Theory — The economics of market making and the spread

• Crypto Orderflow Alpha Report — Feb 2026 — Order book signals and microstructure, February 2026

If I post a limit order, what is the probability it gets filled?

This question governs spread capture, adverse selection, and ultimately PnL.
Fill probabili…

Read more

Formula:

Use Case: Estimating betas, running Fama–French regressions, quick factor tests, small sized alpha fitting.

Read more