Paper Explorer

Harry Markowitz (1952)

Introduced mean-variance optimization (MVO) — the efficient frontier, diversification benefit through covariance.

In this codebase: ⚠️ MVO is implemented as `markowitz_mean_variance_weights` in `_orphan_implementations.py` (deprecated, not in `ALLOCATION_METHODS`). The project's own benchmarks found MVO **does not consistently beat 1/N** out-of-sample, consistent with D

John L. Kelly Jr. (1956)

Maximizes long-term geometric growth rate by maximizing expected log wealth.

In this codebase: ✅ Excellent. `kelly.py` implements the binary criterion, binary optimal fraction (general form `p/l − q/g`), stock fraction, fractional Kelly, Merton fraction (`(μ−r)/(γσ²)`), and Ralph Vince's optimal_f. Risk-of-ruin minimization uses a di

Thomas M. Cover (1991)

Prior-free, minimax-optimal online portfolio algorithm.

In this codebase: ⚠️ The **core algorithm is correct** — simplex sampling → wealth-weighting. However, the project adds several **extensions NOT in Cover's paper**: (1) CVaR-based strategy trimming (removes tail-risky CRPs before wealth-weighting), (2) Adapt

Victor DeMiguel, Lorenzo Garlappi, Raman Uppal (2009)

Compared 14 optimization models (MVO, Bayes-Stein, Black-Litterman, etc.) against naive 1/N across 7 datasets.

In this codebase: ✅ The project explicitly cites this paper and uses it as its core architectural rationale. `equal_weight_alloc` is the benchmark. The `ALLOCATION_METHODS` registry removed all optimization-based methods (kelly, markowitz, hrp, etc.) that fa

Marcos López de Prado (2016)

Introduced Hierarchical Risk Parity (HRP).

In this codebase: ✅ The project implements HRP in `_orphan_implementations.py` (`hrp_weights`) and in `mpm_allocator.py` (via `HRPOptimizer` wrapper). The implementation follows the paper: correlation distance `√(½(1−ρ))`, single-linkage hierarchical cluster

Florin Spinu (2013)

Efficient Newton-method algorithm for computing risk parity (equal risk contribution) portfolios.

In this codebase: ⚠️ The project has `risk_parity_weights` in `_orphan_implementations.py` but it uses **cvxpy (CLARABEL solver)** instead of Spinu's Newton method. The comment references Spinu (2013) but the implementation is a generic QP approach. The proj

Olivier Ledoit, Michael Wolf (2004)

Linear shrinkage of sample covariance matrix toward a structured target (identity × average variance).

In this codebase: ✅ The project uses `LedoitWolf` from `sklearn.covariance` directly via `ledoit_wolf_cov` in `estimators.py` (line 15–29). The implementation calls `LedoitWolf().fit(returns.values)` which is the 2004 linear shrinkage. The project also has a

Robert F. Engle (2002)

Two-step estimator: (1) fit univariate GARCH(1,1) per asset, (2) estimate dynamic conditional correlation via EWMA on standardized residuals.

In this codebase: ⚠️ The project's `dcc_garch_cov` in `estimators.py` implements a simplified version. It fits univariate GARCH(1,1) per asset, then uses a single EWMA covariance on standardized residuals (not the full DCC recursion with α,β parameters). The

Fischer Black, Robert Litterman (1992)

Bayesian approach combining market-equilibrium implied returns (CAPM reverse optimization) with investor views.

In this codebase: ⚠️ `black_litterman_returns` in `estimators.py` implements the BL formula but with **simplified assumptions**: (1) Equal-weight proxy instead of market-cap weights — this loses a key advantage of BL (market-consistent priors), (2) Views are

Robert C. Merton (1969 (Part I), 1971 (Part II))

Continuous-time portfolio problem with CRRA utility.

In this codebase: ✅ The project implements `merton_portfolio_fraction` in `kelly.py` (line 76–84) exactly as `(μ−r)/(γσ²)`. The Merton weights in `_orphan_implementations.py` normalize this to multi-asset allocation. The gamma parameter defaults to 2.0 (mode

Robert E. Whaley (2000)

Demonstrated that the CBOE Volatility Index (VIX) serves as a barometer of investor fear and market sentiment.

In this codebase: ✅ The project's `vix_regime.py` implements VIX-based regime classification that maps VIX trailing percentiles → calm/bear/crisis regimes. This goes beyond Whaley (who identified VIX as sentiment gauge) by directly using it for portfolio dis

Tobias J. Moskowitz, Yao Hua Ooi, Lasse Heje Pedersen (2012)

Documented significant time-series (absolute) momentum across 58 liquid futures — equity index, currency, commodity, and bond.

In this codebase: ✅ The project's `trend_momentum_multiplier` in `overlay.py` implements a sigmoid-mapped trailing-return momentum that multiplies portfolio weights — this is a trend overlay, not pure TSMOM. The project uses multi-window momentum computation

R. Tyrrell Rockafellar, Stanislav Uryasev (2000)

CVaR (expected shortfall) is a coherent risk measure that can be optimized with linear programming.

In this codebase: ⚠️ The project uses CVaR in multiple places but mostly as a **constraint/filter** rather than the LP optimization from Rockafellar-Uryasev. `robust_cvar_weights` in `_orphan_implementations.py` implements the full LP formulation (minimize C

Damian Kisiel, Denise Gorse (2021)

Binary classifier (XGBoost) that selects between Naïve Risk Parity (NRP, inverse-vol) for trending markets and Hierarchical Risk Parity (HRP) for turbulent ones, using regime features (vol, correlation, momentum, skew, drawdown).

In this codebase: ✅ Excellent. The project's `MetaPortfolioMethod` in `mpm_allocator.py` closely follows the paper: XGBoost binary classifier (NRP vs HRP), the same feature set (vol_21d, mean_corr_63d, mom_63d/126d, skew_21d, drawdown_63d, regime_severity),

Ray Dalio (2018)

The "Four-Quadrant" macro framework: classify regimes by growth (↑/↓) × inflation (↑/↓) → Q1 Overheat, Q2 Goldilocks, Q3 Deflation, Q4 Stagflation.

In this codebase: ✅ The project's `quad_classifier.py` implements the Four-Quadrant framework using ETFs (SPY, TLT, TIP, GLD, HYG, SHY) as macro proxies. Growth momentum is computed from SPY + HYG/SHY + TLT/SPY (inverted). Inflation momentum from TIP/TLT + G

J.P. Morgan / RiskMetrics Technical Document (1996 (4th ed.))

Exponentially weighted moving average (EWMA) for covariance estimation.

In this codebase: ✅ The project's `ewma_cov` in `estimators.py` implements this with `λ=0.94`. The implementation uses explicit weight vector `λ^(T−1−i)` which is equivalent to the RiskMetrics recursion. Bessel-like correction `1/(1−Σw²)` is applied.

Damian Kisiel, Denise Gorse (2022 (extension))

Portfolio Transformer — uses attention mechanism across assets and time for allocation.

In this codebase: ❌ Not implemented. The project's approach stops at the XGBoost meta-classifier (MPM) and does not include the transformer architecture.

Various (shrinkage-based portfolio method) (N/A — this is a custom method NOT from a specific paper.)

CRISP — Correlation-Regularised Iterative Shrinkage Portfolios — solves `P_γ w = μ` where `P_γ = (1−γ)·diag(Σ) + γ·Σ`.

In this codebase: The method appears to be the project's own contribution. It is closest in spirit to Ledoit-Wolf shrinkage but applied to the portfolio weight computation rather than covariance estimation. The closed-form linear solve (no fixed-point loop)

Ralph Vince (1990 (Portfolio Management Formulas), 1995 (Mathematics of Money Management))

The "Optimal f" concept — the fraction of capital to risk that maximizes terminal wealth, computed from the worst historical loss rather than theoretical distribution: `f* = ((W/L_ratio + 1)·p − 1) / (W/L_ratio)`.

In this codebase: ✅ The project's `optimal_f_ralph_vince` in `kelly.py` implements this formula exactly. It takes an array of trade returns, computes average win/loss and win probability, and returns f*.

Danijel Jevtic, Romain Délèze, Joerg Osterrieder (ZHAW School of Engineering, Winterthur) (2022)

Compares four ML models (LSTM, Random Forest, Support Vector Regression, k-NN) against conventional benchmarks (ARMA-GARCH and Cross Signal Trading) for directional trading on daily Brent Crude Oil.

Ernest P. Chan (2013)

State-space pairs trading — the hedge ratio is a random-walk latent state estimated by a Kalman filter: `β_t = β_{t-1} + w_t` (state), `y_t = β_t'·x_t + ε_t` (observation), with `x` augmented by ones so β = [slope, offset].

In this codebase: ❌ Not implemented (no pairs/KF module in `portfolio_simulation/` or `quant-studio`). Three things map directly: (1) a `kalman_pairs` signal module with `delta` as the sole hyperparameter, validated walk-forward — not the book's in-sample se

Angelos Filos (Imperial College London, MEng dissertation) (2018 (dissertation, 20 Jun) / 2019 (arXiv, 12 Sep))

Compares forecast-then-optimize pipelines (VAR and RNN — "model-based" in the paper's loose usage, meaning system identification, not RL planning-models) against model-free RL agents: **DSRQN** (Deep Soft Recurrent Q-Network — value-based,

Andrea Frazzini, Lasse Heje Pedersen (AQR / NYU) (2014)

Extends Black (1972) zero-beta CAPM: leverage-constrained investors overweight high-beta assets to hit return targets, overpricing them; unconstrained traders harvest the premium by leveraging a low-beta portfolio to β=1 and shorting a high

In this codebase: ❌ No levered low-beta sleeve exists here. Two capture paths: (a) conservative — low-beta/low-vol tilt without leverage (diluted BAB, no financing risk), implementable as a ranking in `criteria.py`/`allocation.py`; (b) full BAB via futures/m

Jorge Guijarro-Ordonez, Markus Pelger, Greg Zanotti (Stanford) (2019 (first draft) / 2022 (SSRN) / **2025 (Management Science, 4 Dec)**)

The "Residuals, Not Predictions" doctrine executed with rigor: (1) arbitrage portfolios as **residual portfolios from conditional latent pricing factors**; (2) a convolutional transformer extracts time-series signals from the residuals; (3)

Mainak Singha (NASA Goddard / Catholic University of America) (2025)

Viral 13+ Sharpe OOS factor claim; the paper's own text documents disqualifying biases (survivorship, 0.6 bp costs, mislabeled OOS window).

Jingyuan Wang, Yang Zhang, Ke Tang, Junjie Wu, Zhang Xiong (Beihang / Tsinghua / CityU) (2019)

RL portfolio strategy with interpretable attention (temporal intra-asset + cross-asset modules).

Carlos Morales (Quant Solvings SL, Madrid) (2026)

Definition-risk study of the value factor: two honestly-labeled "value" portfolios (sector-relative composite of four accounting ratios vs pooled book-to-market) hold **~7 of 10 names differently**, and the shared 3/10 carry only **13.31%**

In this codebase: ⚠️ Protocol, not code. Actionable for `quant-studio`'s `factors` endpoint: expose construction decisions (ratio set, sector-relative vs pooled, update frequency, universe handling) as first-class documented parameters — a **factor spec shee

Xinyi Li* (Columbia), Yinchuan Li* (Beijing Institute of Technology), Xiao-Yang Liu (Columbia), Christina Dan Wang (NYU Shanghai) — *equal contribution. Same group as the FinRL ecosystem (Liu). (2019)

Midterm (30–60 day) price prediction via forecast-then-optimize.

"Marcus H. Reed, Systematic Trading Research Unit, New York, NY" — none of these verifiable. (2026 (August, per title page).)

As doctrine it is sound, and every claim has a real, citable lineage the artifact fails to provide: (1) *small samples are where delusion lives* — separating luck from repeatability needs many independent trials; formalized as the deflated

In this codebase: ✅ **The most fully implemented doctrine in this catalog** — the note describes, almost section by section, what `quant-studio` + `portfolio_simulation` already do. Small samples → `deflated_sharpe_from_returns` wired through `pipeline.py`/`

Giorgos Iacovides, Wuyang Zhou, Danilo P. Mandic (Imperial College London) (2025)

First finance-specific LLM framework that replaces the supervised fine-tuning (SFT) sentiment-classification paradigm with post-training human-preference alignment via Direct Preference Optimization (DPO).

Vanderveken, Lassance & Vrins (2024)

Optimal number of holdings N ≈ N_sample / 2 for the robust 2F/3F rules under typical equity correlations — estimation risk dominates signal, so adding more assets beyond this point destroys out-of-sample Sharpe faster than it adds diversifi

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Branger, Lucivjanska & Weissensteiner (2019)

Grouping assets into clusters can beat both full mean-variance and 1/N when the group size is chosen optimally — the optimal granularity balances asset heterogeneity against estimation risk.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

da Costa, Pesenti & Targino (2023)

Risk budgeting needs only the covariance matrix (not expected returns); risk parity equalizes risk contributions, cutting concentration versus equal-weight.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

US Treasury (1999)

Peak ~25-30× leverage combined with a 2.5% adverse move wiping out equity and a correlation regime shift produced terminal risk — a case study in how estimation-error and leverage jointly drive ruin.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Nature Scientific Reports (2025)

An LSTM volatility forecaster with regime-switching delivers Sharpe 1.38 (55% over risk parity) via differential risk budgeting — a data-driven alternative to fixed risk-parity weights.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

James & Menzies (2023)

Low-skilled investors should hold ~100 stocks while highly skilled investors should hold ~10 (the paper's experiment bounds) — optimal breadth depends on the investor's stock-selection ability.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Bailey & López de Prado (2014)

Adjusts an observed Sharpe for non-normality, sample length and the number of trials searched — separating genuine edge from selection bias.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Bailey, Borwein, López de Prado & Zhu (2015)

Defines the Probability of Backtest Overfitting (PBO) and the CSCV procedure to estimate the chance that your best in-sample strategy is actually worse than the median out-of-sample.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Almgren & Chriss (2000)

The market-impact model behind realistic fills and capacity: the mean-variance trade-off between market impact and timing risk.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Qian (PanAgora) (2005)

The original risk-parity paper: 60/40 is ~95% stock risk; equal-risk-contribution plus leverage hits a risk target while keeping Sharpe.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Asness, Moskowitz & Pedersen (2013)

Value and momentum premia recur across 8 markets/asset classes, are negatively correlated, and share a global factor structure.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Hamilton (1989)

The Markov-switching model that makes latent bull/bear regimes directly estimable — the statistical basis for regime detection.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Barro (2006)

Equity premia are best explained by low-probability crashes, not normal volatility — why tail/max-drawdown modeling matters.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Fama & French (2015)

Adds profitability and investment to size/value — the workhorse factor model for explaining cross-sectional returns.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Jegadeesh & Titman (1993)

The canonical momentum result: 3-12-month past winners beat losers by ~12%/yr, not explained by beta.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Engle (1982)

The ARCH paper that launched conditional-volatility modeling — ancestor of GARCH and RiskMetrics-style EWMA vol forecasts.

In this codebase: N/A - surfaced in Paper Explorer (web reference) / stored as PDF; not mapped to portfolio_simulation/ allocation methods.

Na, Ni, Szpruch, Wang, Mehta, Nagrecha, Lopez-Lira, Choi, Lee, Lee (2026)

First systematic finance-specific study of how an adversarial signal enters a multi-agent trading system and how far it survives to the final decision.

In this codebase: N/A - adversarial-robustness reference for multi-agent trading systems; not a portfolio-construction method.

Lucas Rabechini Amaral (2026)

Solves the optimal mean-reversion trading rule for a limit order book where the observed mid carries a stationary error around a latent efficient price.

In this codebase: N/A - microstructure optimal-switching reference for limit order book mean-reversion; not a portfolio-construction method. Hasbrouck-style decompositions estimate a statistical permanent component, but they do not provide the exact X_t need

"Elias R. Turner, Systematic Markets Research Group, Boston, MA" — none of these verifiable. (2026 (August, per title page).)

As doctrine it is sound, and every claim has a real, citable lineage the artifact fails to provide: (1) *remove market beta first* — a strategy that merely rides the index is not skill; formalized by the factor-model alpha intercept (Fama-F

In this codebase: ✅ **The doctrine is already implemented in `quant-studio` + `portfolio_simulation`.** Hidden forces → `/api/factors` residual-alpha regression with Newey-West t-stats and `effective_number_of_bets_factor` (`portfolio_simulation/self_audit.p

Olivier Ledoit, Michael Wolf (2020)

Closed-form, asymptotically optimal nonlinear shrinkage that shrinks sample eigenvalues individually (no parametric target), markedly improving portfolio-weight stability when N is large relative to T.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Taras Bodnar, Yarema Okhrin, Nestor Parolya (2022)

Derives analytic shrinkage estimators applied directly to portfolio weights (not only the covariance), proving shrinkage portfolios dominate 1/N under stated high-dimensional conditions.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Gianluca De Nard, Olivier Ledoit, Michael Wolf (2021)

Shows that combining a factor model with nonlinear shrinkage yields a near-optimal estimator for large-portfolio selection.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Amir Ahmadi-Javid (2012)

Introduces EVaR, a coherent risk measure based on the Chernoff bound that dominates CVaR and captures the full tail beyond the VaR threshold.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Tim Bollerslev, George Tauchen, Hao Zhou (2009)

Documents that the variance risk premium (implied minus realized variance) predicts aggregate equity returns, directly relevant to VIX-based regime classification.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Rama Cont, Romain Deguest, Gennaro Scandolo (2010)

Provides a quantitative framework for the robustness and sensitivity of risk measures, identifying when VaR/CVaR estimates become numerically unstable.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Shihao Gu, Bryan Kelly, Dacheng Xiu (2020)

Benchmarks ML methods (neural nets, trees, penalized regressions) for return prediction and finds only weak predictability for truly unexpected returns, supporting skepticism of naive LSTM forecasting.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Jun Liu (2007)

Derives closed-form portfolio solutions to Merton's problem under stochastic volatility and stochastic interest rates, generalizing the constant-parameter Merton fraction.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Geert Bekaert, Maria Hoerova (2014)

Decomposes the VIX into risk aversion and expected volatility, improving VIX-based regime classifiers used for dispatch.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Elad Hazan (2016)

Generalizes Cover's Universal Portfolio to the online convex optimization framework, suggesting more efficient sampling and updating schemes.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.

Sergei Antonov, Alexander Lipton, Marcos López de Prado (2024)

Proves that HRP attains a lower out-of-sample variance than CLA through an improved condition number, giving rigorous justification for HRP.

In this codebase: N/A - surfaced in Paper Explorer (web reference); not yet mapped to portfolio_simulation/ allocation methods.