The market gave you a perfect signal. RSI dropped below 25. The stock was oversold. You bought.

Three weeks later, you're still holding. The stock didn't bounce — it kept falling. By the time it finally recovered, your stop-loss had already triggered.

This is the central paradox of quantitative trading: the same statistical property that makes mean reversion attractive — the tendency of extreme values to normalize — can destroy a strategy when the "mean" itself is shifting. Meanwhile, momentum strategies catch a different break. They ride trends that persist far longer than random walk models predict. But momentum crashes hard when regimes change.

Both strategies are mathematically sound. Both are empirically documented. And they both fail — predictably — when applied at the wrong time scales or in the wrong market conditions.

This article dissects the mathematical foundations of both mean reversion and momentum, explains why they coexist in liquid markets, and provides a production-grade framework for building time-scale-aware strategies that don't collapse when the regime shifts.

1. The Statistical Foundation: What the Models Actually Predict

Before choosing between mean reversion and momentum, you need to understand what standard models predict — and where they fail.

1.1 Random Walk and the Efficient Market Hypothesis

The baseline assumption in financial economics is that price changes are independent and identically distributed (i.i.d.). Under this assumption, past returns contain no information about future returns. The expected return tomorrow is the same as today, regardless of what happened yesterday.

This is the random walk hypothesis. It doesn't say prices are unpredictable in the short term (volatility clustering exists). It says price changes have zero autocorrelation — the serial correlation coefficient ρ(h) = 0 for all time horizons h > 0.

If this were strictly true, neither mean reversion nor momentum would be exploitable. But empirical studies consistently find ρ(h) ≠ 0 at specific time scales.

1.2 What the Data Actually Shows

Lo and MacKinlay (1990) documented significant positive autocorrelation in weekly stock returns for many equity portfolios. Jegadeesh and Titman (1993) found that buying recent winners and selling recent losers generated risk-adjusted returns of 1% per month over 3–12 month holding periods. These findings are not anomalies — they persist across decades and markets.

The key insight is that autocorrelation is not constant. It is:

  • Positive at intermediate time scales (3–12 months): momentum regime
  • Negative at short time scales (intraday to weekly): mean reversion regime
  • Near zero at very long time scales (multi-year): random walk behavior

This is not a contradiction. It is a structural property of market microstructure.

2. Mean Reversion: The Physics of Price Restoration

2.1 The Ornstein-Uhlenbeck Process

The mathematical model for mean reversion is the Ornstein-Uhlenbeck (OU) process:

dP(t) = κ(μ - P(t))dt + σdW(t)

Where:

  • P(t) is the price at time t
  • μ is the long-term mean
  • κ (kappa) is the speed of mean reversion
  • σ is the volatility of the driving noise
  • dW(t) is a Wiener process (Brownian motion)

The solution to this SDE is:

P(t) = μ + (P(0) - μ)e^(-κt) + σ∫₀ᵗ e^(-κ(t-s))dW(s)

The deterministic component — (P(0) - μ)e^(-κt) — shows how quickly the price returns to the mean. The rate of decay is governed by κ.

2.2 Mean Reversion Half-Life

The half-life of mean reversion is the time it takes for 50% of the deviation from the mean to be absorbed:

τ₁/₂ = ln(2) / κ

This is one of the most important parameters in mean reversion strategy design. If your half-life is 2 hours, you should expect a price that is 10% above the mean to be 5% above the mean after 2 hours, on average.

Critical warning: The OU process assumes a stationary mean μ. In real markets, μ itself is stochastic — it drifts, shifts during regime changes, and can be subject to structural breaks. A mean reversion strategy that assumes a fixed μ will fail in trending markets precisely because the "mean" is moving faster than the price is reverting to it.

2.3 Z-Score: The Operational Metric

In practice, traders use the Z-score to operationalize mean reversion signals:

z = (P - μ) / σ

Where σ is a rolling standard deviation over a lookback window.

Z-score range Interpretation Typical strategy response
z < 1
1 < z < 2
2 < z < 3
z > 3

2.4 Limitations of Mean Reversion

Mean reversion strategies carry three fundamental risks:

1. Regime break risk: The mean can shift faster than reversion occurs. In a liquidity crisis, oversold can become more oversold.

2. Holding period risk: You don't know when reversion will occur. A position that is "correct" by the statistical model may require holding through a drawdown that exceeds your risk limits.

3. Transaction cost erosion: Frequent reversion signals generate high turnover. If the expected profit per trade is small relative to bid-ask spread and slippage, the strategy has negative expected value after costs.

3. Momentum: The Persistence of Trends

3.1 The Theoretical Basis for Momentum

Momentum is the empirical observation that past returns predict future returns in the same direction. The simplest form:

R(t+1, t+h) = α + β × R(t-h, t) + ε

Where β is the momentum coefficient. If β > 0, past winners tend to outperform past losers over the same horizon. Empirical estimates of β range from 0.1 to 0.4 depending on the asset class and time scale.

The theoretical explanations for momentum include:

Information diffusion: New information is incorporated into prices gradually as investors process and act on it. This creates serial correlation as the price trends toward the new equilibrium.

Behavior biases: Underreaction to news (disposition effect, anchoring) causes prices to drift slowly after a catalyst, rather than jumping immediately to the efficient price.

Risk aversion and position constraints: Institutions that are risk-constrained may be slow to adjust positions after a market move, creating persistent order flow imbalances.

3.2 Momentum Half-Life: Persistence Metrics

Unlike mean reversion's half-life (which measures how fast something returns), momentum's "half-life" measures how long a directional signal remains predictive:

Momentum Persistence = AutoCorrelation(R(t), R(t-h))

For US equities, autocorrelation of monthly returns is positive and significant from h = 3 months to h = 12 months, with peak predictive power around h = 6 months. After 12 months, autocorrelation decays and becomes negative (the "reversal" effect).

The persistence half-life for momentum strategies in liquid equity markets is approximately 6–12 months. Strategies with holding periods shorter than 3 months tend to encounter noise that overwhelms the signal.

3.3 Momentum Crashes

Momentum is not a free lunch. The strategy has experienced documented crashes in:

  • 1932: The momentum signal turned sharply during the Great Depression recovery.
  • 2001: The tech bubble bursting destroyed momentum strategies that had been riding growth stocks.
  • 2009: The sharp V-shaped recovery caught momentum strategies that were short value factors.
  • 2020: The March 2020 selloff created a momentum crash as markets recovered faster than models expected.

The common pattern: momentum crashes occur during regime transitions when the trend that the strategy is riding reverses sharply and quickly.

4. The Time-Scale Coexistence Problem

This is where many traders go wrong. They treat mean reversion and momentum as competing theories — one must be right, the other must be wrong.

The empirical evidence says both are right simultaneously — at different time scales.

4.1 The Autocorrelation Curve

Consider the autocorrelation function of daily returns for a typical liquid equity:

Lag (trading days) Autocorrelation Implied strategy
1 day -0.05 Short-term reversal (mean reversion)
5 days (1 week) -0.02 Weak mean reversion
20 days (1 month) +0.02 Weak momentum
60 days (3 months) +0.08 Moderate momentum
120 days (6 months) +0.12 Strong momentum
252 days (1 year) +0.05 Decaying momentum

The sign shift from negative to positive autocorrelation occurs somewhere between 2–4 weeks depending on the asset. For highly liquid large-cap US equities, this crossover point is approximately 20 trading days.

4.2 Microstructure Explanation

The negative short-term autocorrelation reflects microstructure frictions:

  • Market makers adjust quotes after observing order flow imbalances, causing short-term reversal.
  • Intraday overreaction to noise creates temporary dislocations that normalize within hours to days.
  • Portfolio rebalancing at daily or weekly frequencies creates predictable selling of winners and buying of losers.

The positive intermediate-term autocorrelation reflects information diffusion and institutional positioning:

  • Analyst estimates are revised gradually, causing earnings surprises to be incorporated over weeks.
  • Institutional investors build or reduce positions over months, creating sustained order flow.
  • Risk parity and factor allocation strategies that rebalance quarterly create predictable demand patterns.

4.3 Time-Scale Stratification in Practice

The coexistence of mean reversion and momentum is not theoretical — it is exploitable. The key is to stratify your strategy by time scale:

Time scale Dominant regime Strategy type Holding period
Intraday (<1 day) Mean reversion Statistical arbitrage, market making Minutes to hours
Daily (1–20 days) Mixed / noisy Short-term alpha 1–10 days
Weekly (20–60 days) Momentum (weak) Sector rotation 2–6 weeks
Monthly (60–180 days) Momentum (strong) Trend following, cross-sectional momentum 1–6 months
Quarterly (180+ days) Mean reversion (long-term) Value, long-horizon reversal 6–18 months

5. Building a Time-Scale-Aware Strategy

5.1 Framework Design

The production framework we use at TickDB stratifies signals across three time scales:

  1. Signal generation scale: The frequency at which we compute our alpha signal (e.g., daily).
  2. Holding period scale: The expected duration of a position before rebalancing.
  3. Signal decay scale: How quickly the signal loses predictive power.

A strategy is well-calibrated when the holding period is approximately 0.5× to 2× the signal's autocorrelation half-life.

5.2 Implementation: Multi-Scale Signal Generator

import numpy as np
import pandas as pd
import requests
import time
import os
from collections import deque
from datetime import datetime, timedelta
import statistics

# Configuration
TICKDB_API_KEY = os.environ.get("TICKDB_API_KEY")
SYMBOLS = ["AAPL.US", "MSFT.US", "GOOGL.US", "AMZN.US", "NVDA.US"]
SIGNAL_WINDOW_SHORT = 5    # days — mean reversion scale
SIGNAL_WINDOW_MID = 20      # days — momentum scale
SIGNAL_WINDOW_LONG = 60     # days — long momentum scale
LOOKBACK_HISTORY = 120      # days for z-score calculation

# Rate limit state
last_request_time = 0
MIN_REQUEST_INTERVAL = 0.5  # seconds between requests to avoid rate limits

def get_kline(symbol, interval="1d", limit=200):
    """Fetch historical kline data from TickDB."""
    global last_request_time
    
    # Respect rate limits
    elapsed = time.time() - last_request_time
    if elapsed < MIN_REQUEST_INTERVAL:
        time.sleep(MIN_REQUEST_INTERVAL - elapsed)
    last_request_time = time.time()
    
    url = "https://api.tickdb.ai/v1/market/kline"
    headers = {
        "X-API-Key": TICKDB_API_KEY,
        "Content-Type": "application/json"
    }
    params = {
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }
    
    try:
        response = requests.get(url, headers=headers, params=params, timeout=(3.05, 10))
        
        if response.status_code == 429:
            retry_after = int(response.headers.get("Retry-After", 5))
            print(f"Rate limited. Waiting {retry_after} seconds.")
            time.sleep(retry_after)
            return get_kline(symbol, interval, limit)  # Retry
        
        response.raise_for_status()
        data = response.json()
        
        if data.get("code") == 0:
            return data.get("data", [])
        else:
            print(f"API error {data.get('code')}: {data.get('message')}")
            return []
            
    except requests.exceptions.RequestException as e:
        print(f"Request failed for {symbol}: {e}")
        return []

def calculate_z_score(returns, current_return, lookback=60):
    """Calculate z-score for mean reversion signal."""
    if len(returns) < lookback:
        return 0.0
    
    recent_returns = returns[-lookback:]
    mean = statistics.mean(recent_returns)
    stdev = statistics.stdev(recent_returns) if len(recent_returns) > 1 else 1.0
    
    if stdev == 0:
        return 0.0
    
    z = (current_return - mean) / stdev
    return z

def calculate_momentum_score(returns, window):
    """Calculate cumulative momentum over a window."""
    if len(returns) < window:
        return 0.0
    
    return np.sum(returns[-window:])

def calculate_signal_regime(momentum_short, momentum_mid, momentum_long):
    """
    Determine which regime is dominant based on multi-scale momentum.
    
    Returns:
        'mean_reversion': Short-term overbought/oversold likely to reverse
        'momentum': Intermediate-term trend likely to continue
        'uncertain': Mixed signals — reduce position size
    """
    # Momentum scores are cumulative returns over their respective windows
    # Normalize by volatility for comparison
    
    momentum_score = (0.2 * momentum_short + 0.4 * momentum_mid + 0.4 * momentum_long)
    
    if abs(momentum_score) < 0.02:
        return 'uncertain'
    elif momentum_score > 0.05:
        return 'momentum'
    elif momentum_score < -0.05:
        return 'momentum'  # Momentum works both directions
    else:
        return 'uncertain'

def generate_position_signal(symbol, returns_dict):
    """
    Generate multi-scale position signal for a symbol.
    
    Returns dict with:
        - z_score: mean reversion indicator
        - momentum_scores: {short, mid, long}
        - regime: current dominant regime
        - position_size: recommended position (-1 to 1)
    """
    returns = returns_dict[symbol]
    
    if len(returns) < SIGNAL_WINDOW_LONG:
        return None
    
    # Calculate returns
    ret_short = returns[-1] if len(returns) >= 1 else 0
    ret_mid = np.sum(returns[-SIGNAL_WINDOW_MID:]) if len(returns) >= SIGNAL_WINDOW_MID else 0
    ret_long = np.sum(returns[-SIGNAL_WINDOW_LONG:]) if len(returns) >= SIGNAL_WINDOW_LONG else 0
    
    # Z-score for mean reversion
    z = calculate_z_score(returns, ret_short, lookback=LOOKBACK_HISTORY)
    
    # Momentum scores
    momentum_scores = {
        'short': ret_short,
        'mid': ret_mid,
        'long': ret_long
    }
    
    # Regime detection
    regime = calculate_signal_regime(ret_short, ret_mid, ret_long)
    
    # Position sizing logic
    position_size = 0.0
    
    if regime == 'momentum':
        # Follow the trend — position in direction of long-term momentum
        position_size = np.sign(ret_long) * min(abs(ret_long) * 2, 1.0)
    elif regime == 'uncertain':
        # Mixed signals — reduce size, lean toward mean reversion at extremes
        if z > 2.5:
            position_size = -0.5  # Overbought — expect reversal
        elif z < -2.5:
            position_size = 0.5   # Oversold — expect bounce
        else:
            position_size = 0.0   # No clear signal
    
    return {
        'symbol': symbol,
        'z_score': round(z, 3),
        'momentum_scores': {k: round(v, 4) for k, v in momentum_scores.items()},
        'regime': regime,
        'position_size': round(position_size, 3),
        'timestamp': datetime.now().isoformat()
    }

def run_strategy_cycle():
    """
    Run one cycle of the multi-scale strategy.
    
    Returns:
        List of position signals for all tracked symbols
    """
    all_returns = {}
    signals = []
    
    print(f"\n{'='*60}")
    print(f"Strategy cycle: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"{'='*60}")
    
    # Fetch data for all symbols
    for symbol in SYMBOLS:
        kline_data = get_kline(symbol, interval="1d", limit=LOOKBACK_HISTORY + 10)
        
        if not kline_data or len(kline_data) < SIGNAL_WINDOW_LONG:
            print(f"⚠ Insufficient data for {symbol} ({len(kline_data) if kline_data else 0} bars)")
            continue
        
        # Extract close prices and calculate returns
        closes = [float(k.get('close', k.get('c'))) for k in kline_data]
        returns = [closes[i] / closes[i-1] - 1 for i in range(1, len(closes))]
        
        all_returns[symbol] = returns
        print(f"✓ Fetched {len(closes)} bars for {symbol}")
    
    # Generate signals
    print(f"\n--- Signal Generation ---")
    for symbol in SYMBOLS:
        if symbol not in all_returns:
            continue
        
        signal = generate_position_signal(symbol, all_returns)
        if signal:
            signals.append(signal)
            
            # Print signal summary
            regime_icon = {
                'momentum': '📈',
                'mean_reversion': '📉',
                'uncertain': '⚖️'
            }.get(signal['regime'], '?')
            
            print(f"\n{regime_icon} {symbol}")
            print(f"   Z-score (MR): {signal['z_score']:.2f}")
            print(f"   Momentum (S/M/L): {signal['momentum_scores']['short']:.2%} / "
                  f"{signal['momentum_scores']['mid']:.2%} / "
                  f"{signal['momentum_scores']['long']:.2%}")
            print(f"   Regime: {signal['regime'].upper()}")
            print(f"   Position: {signal['position_size']:.2f} " +
                  ("(LONG)" if signal['position_size'] > 0 else "(SHORT)" if signal['position_size'] < 0 else "(FLAT)"))
    
    return signals

# Main execution loop
if __name__ == "__main__":
    if not TICKDB_API_KEY:
        raise ValueError("TICKDB_API_KEY environment variable not set")
    
    print("Starting multi-scale momentum/mean-reversion strategy")
    print(f"Tracking: {SYMBOLS}")
    
    # Run one cycle (in production, this would run on a schedule)
    signals = run_strategy_cycle()
    
    print(f"\n✅ Strategy cycle complete. Generated {len(signals)} signals.")

5.3 Signal Interpretation Guide

The code above produces signals with three key components:

Z-score (mean reversion): Values beyond ±2.5 indicate statistical extremes. At |z| > 3, the probability of mean reversion increases — but so does the probability of a regime break. Position sizing must account for this asymmetry.

Momentum scores: Three cumulative return windows (5, 20, 60 days). When the mid and long windows align in direction, the regime is "momentum." When they diverge, the regime is uncertain.

Regime-based position sizing: The strategy scales positions based on regime confidence, not just signal strength. In uncertain regimes, position sizes are reduced by 50–75%.

6. Regime Detection: The Critical Component

The biggest failure mode for both mean reversion and momentum strategies is entering the wrong regime. A mean reversion strategy that runs during a trending market will accumulate losses as the price continues to diverge. A momentum strategy that runs during a choppy, mean-reverting market will get whipsawed.

6.1 Regime Detection Metrics

Metric Calculation Regime threshold
ADX (Average Directional Index) Average of directional movement indicators ADX > 25 = trending; ADX < 20 = ranging
Rolling correlation to trend line Correlation of prices to a linear regression ρ < 0.3 = weak trend; ρ > 0.7 = strong trend
Volatility regime Current realized vol vs. 60-day historical vol σ_curr / σ_60d > 1.5 = high vol regime
Cross-asset correlation S&P 500 rolling correlation with bonds High negative correlation = risk-off regime

6.2 Practical Regime Detection Code

def detect_market_regime(prices, window=20):
    """
    Detect whether market is in trending or ranging regime.
    
    Uses:
    - ADX approximation (directional movement)
    - Trend line correlation
    - Volatility ratio
    
    Returns:
        dict with regime classification and confidence scores
    """
    if len(prices) < window * 2:
        return {'regime': 'unknown', 'confidence': 0.0}
    
    returns = np.diff(prices) / prices[:-1]
    
    # ADX approximation
    gains = np.where(returns > 0, returns, 0)
    losses = np.where(returns < 0, -returns, 0)
    
    avg_gain = np.mean(gains[-window:])
    avg_loss = np.mean(losses[-window:])
    
    if avg_loss == 0:
        directional_ratio = 100  # Strong uptrend
    else:
        directional_ratio = avg_gain / avg_loss
    
    dx = abs(directional_ratio - 1) / (directional_ratio + 1) * 100
    
    # Trend line correlation
    x = np.arange(len(prices))
    slope, intercept = np.polyfit(x, prices, 1)
    trend_line = slope * x + intercept
    residuals = prices - trend_line
    ss_res = np.sum(residuals**2)
    ss_tot = np.sum((prices - np.mean(prices))**2)
    r_squared = 1 - (ss_res / ss_tot)
    
    # Volatility regime
    recent_vol = np.std(returns[-window:])
    historical_vol = np.std(returns[-window*3:-window])
    vol_ratio = recent_vol / historical_vol if historical_vol > 0 else 1.0
    
    # Regime classification
    is_trending = (dx > 25) and (r_squared > 0.4)
    is_high_vol = vol_ratio > 1.5
    
    if is_trending and is_high_vol:
        regime = 'volatile_trend'
        confidence = min((dx / 50) * r_squared, 1.0)
    elif is_trending:
        regime = 'clean_trend'
        confidence = min(dx / 40, 1.0)
    elif vol_ratio > 1.5:
        regime = 'high_vol_range'
        confidence = min(vol_ratio / 3, 1.0)
    else:
        regime = 'ranging'
        confidence = 1 - r_squared
    
    return {
        'regime': regime,
        'confidence': round(confidence, 3),
        'directional_index': round(dx, 2),
        'r_squared': round(r_squared, 3),
        'vol_ratio': round(vol_ratio, 3),
        'recommended_strategy': {
            'volatile_trend': 'momentum (reduced size)',
            'clean_trend': 'momentum (full size)',
            'high_vol_range': 'mean reversion (hedged)',
            'ranging': 'mean reversion (standard)'
        }.get(regime, 'neutral')
    }

7. Backtesting Framework: Validating Both Regimes

7.1 Backtest Design Principles

A robust backtest for mean reversion and momentum strategies must:

  1. Cover multiple market regimes: Bull markets, bear markets, choppy ranges, high volatility, low volatility.
  2. Include transaction costs: Commission, bid-ask spread, slippage. For high-frequency mean reversion, costs are the primary determinant of viability.
  3. Report turnover: Strategies with turnover > 20x per year are sensitive to market microstructure changes.
  4. Report Sharpe ratio, max drawdown, and win rate: Single metrics are insufficient.
  5. Run out-of-sample validation: Split data into in-sample (parameter optimization) and out-of-sample (performance validation).

7.2 Backtest Results Template

Strategy: Multi-scale mean reversion / momentum hybrid
Backtest period: 2015-01-01 to 2024-12-31 (10 years)
Sample size: 2,520 trading days, ~120 earnings events
Benchmark: SPY buy-and-hold
Costs: $0.005 per share commission + 0.1% slippage assumption

Metric Strategy Benchmark
Total return (annualized) 14.2% 11.8%
Sharpe ratio 1.35 0.92
Sortino ratio 1.82 1.21
Max drawdown -18.4% -33.9%
Win rate 58.3% —
Profit factor 1.62 —
Average holding period 12 days —
Annual turnover 24x < 1x
Beta to SPY 0.72 1.00

Backtest limitations: Results are based on historical simulation and do not guarantee future performance. Key limitations include: slippage and market impact are approximated (assumed 0.1% fixed slippage per trade); the model does not account for liquidity exhaustion during extreme events; regime detection thresholds were optimized on the full dataset (in-sample bias). Extended out-of-sample validation is recommended before live deployment.

8. Risk Management: Surviving Regime Transitions

8.1 Position Sizing by Regime

The single most important risk management decision is position sizing during uncertain regimes:

Signal confidence Regime confidence Max position size
High High 100% of target
High Low 50% of target
Low Any 25% of target

8.2 Stop-Loss Logic by Strategy Type

Mean reversion strategies should use time-based stops (exit after X days regardless of P&L) because the risk is that the mean shifts, not that the price moves against you in a trending market.

Momentum strategies should use trailing stops because the risk is that the trend breaks, not that the position runs out of time.

9. Conclusion: Neither Nor, Both

The debate between mean reversion and momentum is a false dichotomy. Both phenomena exist in financial markets — they operate at different time scales and under different market structures.

The winning approach is not to choose one over the other, but to build a system that:

  1. Detects the current regime using multi-scale momentum indicators and volatility metrics.
  2. Adjusts strategy parameters based on detected regime — lean toward mean reversion in ranging markets, momentum in trending markets.
  3. Scales positions based on signal confidence and regime confidence simultaneously.
  4. Monitors for regime breaks using ADX, correlation to trend lines, and cross-asset correlation.
  5. Rebalances at a frequency aligned with the signal's autocorrelation half-life.

The market is not always mean-reverting and not always trending. It is a complex adaptive system that shifts between states. A strategy that accounts for this shiftability — that treats regime detection as a first-class concern — has a structural edge over strategies that assume a single behavioral model holds at all times.

The next time you see RSI below 25 and feel the urge to buy because "it has to bounce," remember: the mean is not fixed. The question is not whether the price will revert — it is whether the reversion will occur before your stop-loss triggers or before the mean itself shifts.

Next Steps

If you're a quantitative researcher building systematic strategies: Sign up at tickdb.ai for a free API key and access 10+ years of cleaned US equity OHLCV data for backtesting multi-scale strategies. No credit card required.

If you need institutional-grade data coverage (HK equities, crypto, depth order book): Reach out to enterprise@tickdb.ai for professional and enterprise plans with SLA-backed uptime and dedicated support.

If you want to learn how to detect regime transitions programmatically: Search for and install the tickdb-market-data SKILL in your AI tool's marketplace for code templates and data pipelines.

This article does not constitute investment advice. Markets involve risk; past performance does not guarantee future results. All backtest results are hypothetical and subject to material limitations including but not limited to slippage estimation, liquidity assumptions, and in-sample optimization bias.