Learn look-ahead bias avoidance — Stock-Market notes

What is Look-Ahead Bias?

Definition Look-Ahead Bias

Look-ahead bias occurs when a trading strategy uses information in backtesting that would not have been available at the time the simulated trade decision was made. This creates artificially inflated performance metrics that don't reflect real-world tradability.

Two core forms:

Data look-ahead: Using revised/restated data instead of the originally reported values, or using a value before its actual availability date
Temporal look-ahead: Using today's close price to generate today's signal (acting on info before it exists)

Related but distinct: Survivorship bias (only testing on stocks that survived to present day) is a data-selection bias, not strictly a look-ahead issue—though the two often appear together. Keep them conceptually separate: look-ahead is about time of availability, survivorship is about which entities were included.

Why Look-Ahead Bias Happens

Root causes:

Data timestamp confusion: Financial data has multiple timestamps (report date, filing date, announcement time, database update time). Using the wrong one creates bias.
Point-in-time data unavailability: Most data vendors provide current/restated data, not the exact values available historically.
Invisible corporate actions: Stock splits, delistings, and bankruptcies are handled retroactively in cleaned datasets.
Signal-execution misalignment: Generating a signal at time T but assuming execution at time T (impossible—execution requires at least T+1).

How to Detect Look-Ahead Bias

Method 1: Forward-Walk Verification

Derivation from first principles:

Let $S_t$ = strategy signal at time $t$ , $I_t$ = information set available at time $t$ .

Causal constraint: $S_t$ must be a function of $I_t$ only: $S_t = f(I_t) \quad \text{where } I_t \cap I_{>t} = \emptyset$

The information set at time $t$ is strictly disjoint from future information.

Test: For each decision timestamp $t$ :

Reconstruct $I_t$ using only data timestamped ≤ $t$
Regenerate $S_t$
Compare with backtest signal

If $S_t^{\text{backtest}} \neq f(I_t)$ , look-ahead bias exists.

Why this step? We're verifying the causal arrow only points backward in time.

Method 2: Reasonable Performance Bounds

Derivation from first principles:

Suppose we estimate a strategy's Sharpe ratio $SR_s$ over $N$ periods and compare it to a benchmark $SR_m$ . The standard error of a Sharpe estimate over $N$ observations is approximately:

$\sigma_{SR} \approx \frac{1}{\sqrt{N}}$

(for i.i.d. returns; it already shrinks as $N$ grows). To ask "is the strategy's Sharpe significantly above the benchmark?", we form a standard z-statistic by dividing the difference by its standard error:

$z = \frac{SR_s - SR_m}{\sigma_{SR}}$

Flag condition: We investigate for bias when

$z = \frac{SR_s - SR_m}{\sigma_{SR}} > 2$

Why no extra $\sqrt{N}$ ? Because $\sigma_{SR}$ already contains the $1/\sqrt{N}$ scaling. Multiplying by another $\sqrt{N}$ would double-count the sample size and make the test wrong. The correct significance test is simply $(SR_s - SR_m)/\sigma_{SR} > 2$ (roughly 95% confidence).

Why this step? Extremely high Sharpe ratios (>3 for daily strategies, >5 for intraday) produce huge $z$ -values—a statistical red flag. The market is competitive; persistent excess returns require explanation beyond luck. Unrealistically good results often indicate data leakage, not genius.

Avoidance Strategies

Strategy 1: Timestamp Discipline

Example implementation:

# WRONG - look-ahead bias
df['signal'] = (df['close'] > df['ma_20'])  # Uses today's close for today's signal
 
# RIGHT - proper timing
df['signal'] = (df['close'].shift(1) > df['ma_20'].shift(1))  # Yesterday's data for today

Why this step? Shifting ensures the signal uses only information that existed before the trading decision.

Strategy 2: Point-in-Time Database

Concept: Store every value with its availability timestamp, not its reference timestamp.

Schema design:

| symbol | metric | value | ref_date | avail_date | |--------|-------|----------|----------| | AAPL | EPS | 1.20 | 2024-12-31 | 2025-01-28 | | AAPL | EPS | 1.24 | 2024-12-31 | 2025-02-15 |← restated

Query rule:

SELECT value 
FROM fundamentals 
WHERE symbol = 'AAPL' 
  AND ref_date = '2024-12-31'
  AND avail_date <= :backtest_date  -- Key: as-of filter
ORDER BY avail_date DESC 
LIMIT 1;

Why this step? This captures the exact value a trader would have seen on any historical date, including revisions.

Strategy 3: Trade-at-Open Protocol

Rule: Generate signals using data up to yesterday's close, execute at tomorrow's open.

Timeline: $t_{\text{data cutoff}} = \text{Day } T\text{'s close} \quad \Rightarrow \quad t_{\text{signal}} = \text{Day } T+1\text{'s open}$

Why? This conservative approach guarantees no intraday look-ahead and accounts for overnight processing time.

Worked example Worked Example: Momentum Strategy

Scenario: Test a 20-day momentum breakout strategy on AAPL, 2024-01 to 2024-12-31.

Step 1: Define the signal. A breakout means "yesterday's close exceeded the highest close of the 20 days before yesterday": $S_t = \mathbb{1}\left\{ P_{t-1} > \max_{i=2}^{21} P_{t-i} \right\}$ where $P_t$ = close price on day $t$ , $\mathbb{1}$ = indicator function.

Why this step? The candidate price $P_{t-1}$ must be compared against a window that excludes itself—i.e., $P_{t-2}, P_{t-3}, \dots, P_{t-21}$ . Otherwise you compare $P_{t-1}$ against a max that already contains $P_{t-1}$ , and the strict-greater test can never fire correctly.

Step 2: Verify timestamps

Signal calculated: After market close on day $t-1$
Execution: Market open on day $t+1$ (needs the open, which is after the signal)
Data used: All prices $\leq$ day $t-1$

Check: Can we compute $\max_{i=2}^{21} P_{t-i}$ after day $t-1$ closes? Yes—all 20 historical prices ( $P_{t-2}$ through $P_{t-21}$ ) are available.

Why this step? Explicit verification that every input is strictly in the past.

Step 3: Code implementation

# Window is the 20 closes BEFORE yesterday's close:
# shift(2) drops today (t) and yesterday (t-1), rolling(20) covers t-2..t-21
df['max_20'] = df['close'].shift(2).rolling(20).max()
 
# Signal: yesterday's close (shift(1)) breaks above that window
df['signal'] = (df['close'].shift(1) > df['max_20']).astype(int)
 
# Execution: enter at the OPEN following the signal, hold to next open.
# Signal known after close of t-1 -> trade open-to-open of days t..t+1
df['open_ret'] = df['open'].shift(-1) / df['open'] - 1   # open[t+1]/open[t]-1
df['returns'] = df['signal'] * df['open_ret']

Why shift(2) for the window? It removes both today ( $t$ ) and the candidate day ( $t-1$ ) so the max spans exactly $P_{t-2}\dots P_{t-21}$ —matching the formula.

Why open-to-open returns? Because we execute at the open, the realized P&L is the change from the open we bought at to the next open we exit at—not the close-to-close return, which we could never have captured.

Result: Sharpe ratio ≈ 0.8 (realistic), max drawdown ≈ 18%, no look-ahead bias detected.

Worked example Worked Example: Earnings Surprise Strategy

Scenario: Buy stocks that beat earnings by >5%, sell those that miss by >5%.

Naive approach (WRONG):

df['surprise'] = (df['eps_actual'] - df['eps_estimate']) / df['eps_estimate']
df['signal'] = np.where(df['surprise'] > 0.05, 1, -1)

Problem: When is eps_actual available? Not on the reference date—on the announcement date!

Why this fails: If AAPL's Q4 2024 earnings (ref_date = 2024-12-31) are announced on 2025-01-28, using them on 2024-12-31 is time travel.

Correct approach:

df['announce_date'] = df['earnings_announce_date']  # Explicitly tracked
df['avail_next_day'] = df['announce_date'] + pd.Timedelta(days=1)  # T+1 trade
df_trades = df[df.index >= df['avail_next_day']]  # Only trade after announcement

Why this step? We merge on the actual announcement date, not the fiscal period end date.

Result: Sharpe ratio drops from 2.4 (biased) to 0.6 (realistic). The bias was worth ~15% annual return that never existed.

Common Mistakes

Common mistake Mistake 2: Rolling Window Includes the Candidate Bar

Wrong idea: For a breakout, write df['close'].shift(1).rolling(20).max() and compare it to df['close'].shift(1).

Why it feels right: "shift(1) means yesterday—so I'm not using today, I'm safe."

Reality: shift(1).rolling(20).max() covers $P_{t-1}\dots P_{t-20}$ , which includes $P_{t-1}$ itself. Comparing $P_{t-1}$ against a max that already contains $P_{t-1}$ means the strict-greater breakout can never trigger properly.

The fix: Shift the window one more (shift(2).rolling(20).max()) so it spans $P_{t-2}\dots P_{t-21}$ , excluding the candidate.

Impact: A silently broken signal that generates almost no trades (or wrong ones).

Common mistake Mistake 3: Confusing Survivorship Bias With Look-Ahead Bias

Wrong idea: "Survivorship is just another type of look-ahead bias, so fixing one fixes the other."

Why it feels right: Both inflate backtests and both involve "knowing something about the future."

Reality: They are distinct. Look-ahead bias is about time of information availability (using data before it existed). Survivorship bias is a data-selection bias (excluding delisted/dead entities from the universe). You can eliminate look-ahead entirely and still have survivorship bias, and vice versa.

The fix: Address them separately—use point-in-time timestamps for look-ahead, and a survivorship-bias-free universe with historically accurate constituents for survivorship.

Impact: Treating them as one leads you to "fix" only half the problem.

Prevention Checklist

Before running any backtest:

☐ Every data field has an explicit availability timestamp
☐ Signal generation uses only data[t-1] for decision at t
☐ Rolling windows exclude the candidate bar itself
☐ Returns match execution timing (open-to-open if trading at open)
☐ Execution assumes realistic delay (open, or close+1 day)
☐ Corporate actions applied on their effective date, not retroactively
☐ Index constituents verified as of backtest date (survivorship handled separately)
☐ Results pass the "reasonable Sharpe" test ( $z=(SR_s-SR_m)/\sigma_{SR}<2$ ; SR < 3 daily)
☐ Forward walk-through done on 10 random dates

Recall Explain to a 12-Year-Old

Imagine you're playing a video game where you're trying to guess which team will win a soccer match. Look-ahead bias is like watching the game, seeing who wins, and then going back in time to "predict" the winner. Of course you'll get it right 100% of the time—you already know!

In stock trading, look-ahead bias is when you test a strategy using information you wouldn't have actually had. Like using today's final stock price to decide whether to buy this morning. That's cheating! When you try it for real (without time travel), your strategy fails.

To avoid it: pretend you're actually living in the past. Only use news, prices, and reports that existed BEFORE you make each decision. It's like playing the game fair—no peeking at the ending!

Connections

6.1.01-Understand-backtest-fundamentals - Foundational backtest design
6.2.03-Handle-survivorship-bias - Related but distinct data-selection bias
6.2.05-Account-for-transaction-costs - Realistic execution modeling
6.3.02-Implement-walk-forward-analysis - Validation method that helps detect look-ahead
7.1.04-Handle-asof-merges-in-pandas - Technical implementation of point-in-time data

#flashcards/stock-market

What is look-ahead bias?

Using information in a backtest that would not have been available at the time the simulated trade decision was made, artificially inflating performance.

How does look-ahead bias differ from survivorship bias?

Look-ahead bias is about time of information availability (using data before it existed); survivorship bias is a data-selection bias (excluding delisted/dead entities). They are distinct though often co-occur.

Why does look-ahead bias occur with adjusted stock prices?

Adjusted prices apply splits and dividends retroactively to all historical data, but traders wouldn't have known about future corporate actions when making past decisions.

What is the as-of data rule?

For any calculation at time t, use only data with data_timestamp ≤ t - delay, where delay accounts for reporting, processing, and market delays.

What timeline should you follow to avoid look-ahead bias?

Generate signals using data up to yesterday's close (day T), execute at the next open (day T+1), ensuring at least one session lag.

Why can't you trade on today's close price?

You only know the close price after the market closes, so the trading opportunity has already passed. You must wait until the next trading session.

What is the correct significance test for a suspiciously high Sharpe?

z = (SR_s − SR_m) / σ_SR > 2, where σ_SR already scales as 1/√N. No extra √N factor is applied.

Why is it wrong to write (SR_s − SR_m) > 2√N·σ_SR?

Because σ_SR already contains the 1/√N scaling; multiplying by another √N double-counts the sample size and breaks the test.

In a 20-day breakout using yesterday's close P_{t-1}, what window should the max span?

P_{t-2} through P_{t-21} (i.e., shift(2).rolling(20)), excluding the candidate P_{t-1} itself.

If you execute at the open, which return should the backtest use?

Open-to-open (open[t+1]/open[t] − 1) or open-to-close matching entry timing—never close-to-close, which is untradeable.

What is a point-in-time database?

A database that stores every data value with its availability timestamp (not just reference timestamp), allowing queries for "what did this value look like on historical date X."

What Sharpe ratio threshold suggests possible look-ahead bias?

Daily strategies with Sharpe > 3 or intraday strategies with Sharpe > 5 are red flags requiring investigation for bias or data leakage.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, look-ahead bias ka core idea bilkul simple hai — jab hum strategy ko backtest karte hain, tab humein sirf wahi information use karni chahiye jo us waqt actually available thi. Jaise agar tum 2020 mein trade decision le rahe ho, toh 2021 ki earnings surprise ka data use karna cheating hai. Yeh bilkul aisa hai jaise poker khelte waqt opponent ke cards pehle dekh lena. Real trading mein future ka data available nahi hota, isliye tumhara signal $S_t$ sirf $I_t$ (us time tak available information) ka function hona chahiye — future information ke saath koi overlap nahi.

Ab yeh matter kyun karta hai? Kyunki look-ahead bias tumhare backtest results ko 20-300% tak inflate kar deta hai. Matlab paper pe strategy genius lagegi, but live trading mein disaster ho jayega — kyunki tum "cheating" kar rahe the future data se. Common galtiyaan hoti hain data timestamp confusion (report date vs filing date vs availability date), point-in-time data ki unavailability, aur signal-execution misalignment — jaise aaj ka close price use karke aaj ka hi signal banana, jo practically impossible hai (execution kam se kam T+1 pe hi ho sakta hai).

Isse detect karne ke do simple tareeke hain. Ek — forward-walk verification: har decision timestamp pe sirf us time tak ka data use karke signal dobara banao aur backtest signal se compare karo; agar match nahi karta toh bias hai. Doosra — reasonable performance bounds: agar tumhara Sharpe ratio bahut hi zyada hai (daily strategy mein >3 ya intraday mein >5), toh z-statistic $(SR_s - SR_m)/\sigma_{SR} > 2$ check karo. Yaad rakhna, $\sigma_{SR}$ mein already $1/\sqrt{N}$ scaling included hai, isliye extra $\sqrt{N}$ multiply mat karna — warna sample size double-count ho jayega. Market competitive hai, toh unreal returns hamesha ek red flag hote hain jinki investigation zaroori hai.

Test yourself — Backtesting Frameworks

Connections