In the previous post we saw that lag effects in daily stock returns are generally weak — a finding consistent with the efficient market hypothesis. But zoom in to 1–5 minute bars and a strikingly different picture emerges.
At intraday timescales, markets are not fully efficient. Information does not instantaneously diffuse to all related assets. Instead it propagates: a price move in a large, liquid stock will typically appear in its smaller peer a few minutes later. This is the lead-lag effect, and it is one of the most robust empirical facts in market microstructure.
This post covers:
# pip install yfinance pandas numpy matplotlib seaborn scipy statsmodels
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import seaborn as sns
from scipy import stats
from statsmodels.tsa.stattools import grangercausalitytests
import warnings
warnings.filterwarnings('ignore')
plt.rcParams['figure.dpi'] = 120
plt.rcParams['font.size'] = 11
sns.set_theme(style='whitegrid')Before touching real data, we build intuition with a controlled simulation. We construct two price series where Asset A leads Asset B by exactly 3 intervals.
\[ A_t = A_{t-1} + \varepsilon_t, \quad \varepsilon_t \sim \mathcal{N}(0, \sigma^2) \]
\[ B_t = B_{t-1} + \alpha \cdot \varepsilon_{t-3} + \eta_t, \quad \eta_t \sim \mathcal{N}(0, \nu^2) \]
Here \(\alpha\) controls how strongly B follows A, and \(\eta_t\) is idiosyncratic noise for B. The true CCF should peak at lag \(k = 3\).
np.random.seed(42)
n = 5000 # 5,000 five-minute bars ≈ 6.6 months of trading days
lag_true = 3 # A leads B by 3 bars
alpha = 0.6 # strength of lead-lag
sigma = 1.0 # A's innovation std
nu = 0.5 # B's idiosyncratic noise std
eps = np.random.normal(0, sigma, n + lag_true)
eta = np.random.normal(0, nu, n)
# Log-return level (innovations)
ret_A = eps[lag_true:]
ret_B = alpha * eps[:n] + eta # B picks up A's innovation from 3 bars ago
# Cumulative price series
price_A = 100 * np.exp(np.cumsum(ret_A) / 100)
price_B = 100 * np.exp(np.cumsum(ret_B) / 100)
t = pd.date_range('2024-01-02 09:30', periods=n, freq='5min')
sim = pd.DataFrame({'Asset A': price_A, 'Asset B': price_B}, index=t)fig, axes = plt.subplots(2, 1, figsize=(13, 7), sharex=True)
# Price paths
axes[0].plot(sim.index[:500], sim['Asset A'][:500], label='Asset A (leader)', lw=1.2, color='steelblue')
axes[0].plot(sim.index[:500], sim['Asset B'][:500], label='Asset B (follower)', lw=1.2, color='darkorange', alpha=0.8)
axes[0].set_title('Simulated Prices — First 500 Bars (≈ 2 Trading Days)', fontsize=12)
axes[0].set_ylabel('Price')
axes[0].legend()
# Returns
axes[1].plot(sim.index[:500], ret_A[:500], label='Return A', lw=0.8, color='steelblue', alpha=0.7)
axes[1].plot(sim.index[:500], ret_B[:500], label='Return B', lw=0.8, color='darkorange', alpha=0.7)
axes[1].set_title('Simulated Log-Returns', fontsize=12)
axes[1].set_ylabel('Log Return')
axes[1].legend()
axes[1].xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.tight_layout()
plt.show()
def compute_ccf(x, y, max_lag=30):
"""Compute cross-correlation at lags -max_lag to +max_lag."""
n = len(x)
x = (x - x.mean()) / x.std()
y = (y - y.mean()) / y.std()
lags = np.arange(-max_lag, max_lag + 1)
ccf_vals = []
for k in lags:
if k == 0:
ccf_vals.append(np.mean(x * y))
elif k > 0:
ccf_vals.append(np.mean(x[:-k] * y[k:]))
else:
ccf_vals.append(np.mean(x[-k:] * y[:k]))
return lags, np.array(ccf_vals)
def plot_ccf(x, y, name_x, name_y, max_lag=20, ax=None, title_suffix=''):
n = len(x)
conf = 1.96 / np.sqrt(n)
lags, ccf_vals = compute_ccf(x, y, max_lag)
colors = ['tomato' if abs(v) > conf else 'steelblue' for v in ccf_vals]
if ax is None:
fig, ax = plt.subplots(figsize=(10, 4))
ax.bar(lags, ccf_vals, color=colors, width=0.7)
ax.axhline( conf, color='black', linestyle='--', lw=0.9, label='95% CI')
ax.axhline(-conf, color='black', linestyle='--', lw=0.9)
ax.axhline(0, color='black', lw=0.5)
ax.axvline(0, color='gray', lw=0.8, linestyle=':')
ax.set_xlabel('Lag (bars) — positive: X leads Y')
ax.set_ylabel('Correlation')
ax.set_title(f'CCF: {name_x} (X) → {name_y} (Y){title_suffix}', fontsize=11)
ax.legend(fontsize=8)
return lags, ccf_vals
fig, ax = plt.subplots(figsize=(11, 4))
plot_ccf(ret_A, ret_B, 'Asset A', 'Asset B', max_lag=15, ax=ax,
title_suffix=f' [True lag = {lag_true} bars, α = {alpha}]')
ax.axvline(lag_true, color='red', lw=1.5, linestyle='--', label=f'True lag = {lag_true}')
ax.legend(fontsize=8)
plt.tight_layout()
plt.show()
The CCF peaks sharply at lag \(k = 3\) (red dashed line), confirming that the method correctly identifies the lead-lag structure even with substantial idiosyncratic noise.
We use yfinance to download 5-minute bars for NVIDIA (NVDA) and Advanced Micro Devices (AMD) — both GPU/AI chip makers with a close fundamental relationship, analogous to Samsung Electronics and SK Hynix in Korean semiconductors.
tickers = ['NVDA', 'AMD', 'INTC', 'MU']
names = {'NVDA': 'NVIDIA', 'AMD': 'AMD', 'INTC': 'Intel', 'MU': 'Micron'}
df_all = yf.download(tickers, period='60d', interval='5m', progress=False, auto_adjust=True)
hf = df_all['Close'][tickers].dropna()
hf.index = pd.to_datetime(hf.index)
# Remove pre/after-market rows (keep 09:30–16:00 EST)
hf = hf.between_time('09:30', '15:55')
print(f"5-min bars: {len(hf)}")
print(f"Period : {hf.index[0]} → {hf.index[-1]}")5-min bars: 1126
Period : 2025-12-17 14:30:00+00:00 → 2026-03-16 15:55:00+00:00# Log returns
ret_hf = np.log(hf / hf.shift(1)).dropna()
# Remove overnight gaps (first bar of each day)
ret_hf = ret_hf.groupby(ret_hf.index.date, group_keys=False).apply(lambda g: g.iloc[1:])one_week = hf[hf.index >= hf.index[-1] - pd.Timedelta(days=7)]
norm_week = one_week / one_week.iloc[0] * 100
fig, ax = plt.subplots(figsize=(13, 5))
colors_ = ['steelblue', 'darkorange', 'forestgreen', 'crimson']
for col, c in zip(norm_week.columns, colors_):
ax.plot(norm_week.index, norm_week[col], label=names[col], lw=1.2, color=c)
ax.axhline(100, color='black', lw=0.7, linestyle='--', alpha=0.4)
ax.set_title('Normalized 5-Minute Prices — Last 7 Calendar Days', fontsize=12)
ax.set_ylabel('Price Index (Base = 100)')
ax.legend()
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d %H:%M'))
plt.xticks(rotation=30)
plt.tight_layout()
plt.show()
One of the most surprising facts about high-frequency correlations is the Epps effect (Epps, 1979): the contemporaneous correlation between two stocks decreases as the sampling interval shrinks.
This seems paradoxical — shouldn’t more data give a better picture? The reason is asynchronous trading: at 1-minute resolution, the two stocks may not have traded within the same bar, so their price changes appear uncorrelated even when they share common information. As the interval widens, the trades overlap and correlation recovers.
# Compute correlation between NVDA and AMD at different frequencies
freqs = {
'1min': '1min',
'5min': '5min',
'15min': '15min',
'30min': '30min',
'1h': '1h',
'1day': '1D',
}
epps_corrs = {}
for label, freq in freqs.items():
try:
resampled = hf[['NVDA', 'AMD']].resample(freq).last().dropna()
# remove overnight gaps
r = np.log(resampled / resampled.shift(1)).dropna()
if len(r) > 10:
epps_corrs[label] = r['NVDA'].corr(r['AMD'])
except Exception:
pass
epps_df = pd.Series(epps_corrs)
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(epps_df.index, epps_df.values, 'o-', color='steelblue', lw=2, ms=8)
for i, (k, v) in enumerate(epps_df.items()):
ax.annotate(f'{v:.3f}', (i, v), textcoords='offset points', xytext=(0, 10), ha='center', fontsize=9)
ax.set_title('Epps Effect: NVDA–AMD Correlation by Sampling Frequency', fontsize=12)
ax.set_ylabel('Pearson Correlation (log returns)')
ax.set_xlabel('Sampling Interval')
ax.set_ylim(0, 1)
ax.axhline(epps_df.iloc[-1], color='gray', lw=0.8, linestyle='--', alpha=0.6, label='Daily level')
ax.legend(fontsize=9)
plt.tight_layout()
plt.show()
Key insight: Correlation at 1-minute intervals is substantially lower than at daily intervals, even for two closely related stocks. This is the Epps effect — it means that measuring co-movement at very short intervals understates the true economic relationship.
Even though contemporaneous correlation is lower at high frequency, lagged correlations are much more informative. Here we compute the CCF for all pairs at 5-minute resolution.
x_hf = ret_hf['NVDA'].values
y_hf = ret_hf['AMD'].values
fig, axes = plt.subplots(1, 2, figsize=(14, 4))
plot_ccf(x_hf, y_hf, 'NVDA', 'AMD', max_lag=20, ax=axes[0],
title_suffix=' [5-min bars]')
# Also show daily comparison
df_daily = yf.download(['NVDA', 'AMD'], period='2y', interval='1d', progress=False, auto_adjust=True)
prices_daily = df_daily['Close'][['NVDA', 'AMD']].dropna()
daily_aligned = np.log(prices_daily / prices_daily.shift(1)).dropna()
plot_ccf(daily_aligned['NVDA'].values, daily_aligned['AMD'].values,
'NVDA', 'AMD', max_lag=20, ax=axes[1],
title_suffix=' [Daily bars]')
plt.suptitle('CCF at Different Frequencies: NVDA (X) → AMD (Y)', fontsize=13, y=1.02)
plt.tight_layout()
plt.show()
Comparison: At the daily level, all CCF bars fall within the confidence bounds — consistent with market efficiency. At 5-minute resolution, significant lags emerge: a move in NVDA today predicts AMD in the next few bars.
pairs = [
('NVDA', 'AMD'),
('NVDA', 'MU'),
('AMD', 'INTC'),
('NVDA', 'INTC'),
]
fig, axes = plt.subplots(2, 2, figsize=(14, 9))
axes = axes.flatten()
for ax, (a, b) in zip(axes, pairs):
x = ret_hf[a].values
y = ret_hf[b].values
plot_ccf(x, y, names[a], names[b], max_lag=15, ax=ax,
title_suffix=' [5-min]')
plt.suptitle('CCF at 5-Minute Resolution: Semiconductor Pairs', fontsize=13, y=1.01)
plt.tight_layout()
plt.show()
We summarize the lead-lag relationship by finding the lag at which the CCF is maximised (in absolute value) for each ordered pair.
stocks = ['NVDA', 'AMD', 'INTC', 'MU']
max_lag_search = 10
lead_lag_matrix = pd.DataFrame(index=stocks, columns=stocks, dtype=float)
peak_lag_matrix = pd.DataFrame(index=stocks, columns=stocks, dtype=int)
for a in stocks:
for b in stocks:
if a == b:
lead_lag_matrix.loc[a, b] = 1.0
peak_lag_matrix.loc[a, b] = 0
continue
lags, ccf_vals = compute_ccf(ret_hf[a].values, ret_hf[b].values, max_lag_search)
# restrict to positive lags only (a leads b)
pos_mask = lags > 0
best_idx = np.argmax(np.abs(ccf_vals[pos_mask]))
best_lag = lags[pos_mask][best_idx]
best_val = ccf_vals[pos_mask][best_idx]
lead_lag_matrix.loc[a, b] = round(best_val, 4)
peak_lag_matrix.loc[a, b] = int(best_lag)
fig, axes = plt.subplots(1, 2, figsize=(13, 5))
sns.heatmap(lead_lag_matrix.astype(float), annot=True, fmt='.3f',
cmap='RdYlGn', vmin=0, vmax=0.5, center=0.15,
linewidths=0.5, ax=axes[0], annot_kws={'size': 11})
axes[0].set_title('Peak CCF Value\n(Row leads Column, positive lags only)', fontsize=11)
axes[0].set_xlabel('Follower (Y)')
axes[0].set_ylabel('Leader (X)')
sns.heatmap(peak_lag_matrix.astype(float), annot=True, fmt='.0f',
cmap='Blues', linewidths=0.5, ax=axes[1], annot_kws={'size': 11})
axes[1].set_title('Lag (5-min bars) at Peak CCF\n(Row leads Column)', fontsize=11)
axes[1].set_xlabel('Follower (Y)')
axes[1].set_ylabel('Leader (X)')
plt.suptitle('Lead-Lag Summary: 5-Minute Semiconductor Returns', fontsize=13, y=1.02)
plt.tight_layout()
plt.show()
Lead-lag effects are not uniform throughout the trading day. They tend to be stronger at the open (when information from overnight is being absorbed) and at the close (end-of-day portfolio rebalancing). We test this by computing the 1-lag cross-correlation in rolling intraday windows.
ret_hf_copy = ret_hf.copy()
ret_hf_copy['hour'] = ret_hf_copy.index.hour + ret_hf_copy.index.minute / 60
bins = np.arange(9.5, 16.5, 0.5) # 30-min buckets
labels = [f'{int(h):02d}:{int((h%1)*60):02d}' for h in bins[:-1]]
ret_hf_copy['bucket'] = pd.cut(ret_hf_copy['hour'], bins=bins, labels=labels)
lag1_by_bucket = (
ret_hf_copy.groupby('bucket', observed=True)
.apply(lambda g: g['NVDA'].corr(g['AMD'].shift(1)))
)
fig, ax = plt.subplots(figsize=(12, 4))
colors_bar = ['tomato' if v > 0 else 'steelblue' for v in lag1_by_bucket.values]
ax.bar(range(len(lag1_by_bucket)), lag1_by_bucket.values, color=colors_bar, width=0.7)
ax.axhline(0, color='black', lw=0.6)
ax.set_xticks(range(len(lag1_by_bucket)))
ax.set_xticklabels(lag1_by_bucket.index, rotation=45, ha='right', fontsize=8)
ax.set_title('Intraday Pattern of Lead-Lag Strength\nNVDA (lag-1) → AMD Correlation by 30-min Bucket', fontsize=12)
ax.set_ylabel('Lag-1 Correlation')
plt.tight_layout()
plt.show()
Just as daily rolling correlations change with market regimes, 5-minute lead-lag also evolves over time. High-volatility periods (earnings, macro events) tend to amplify price discovery dynamics.
# Compute rolling lag-1 cross-correlation on daily windows
# Each "day" has ~78 five-minute bars (6.5 hours × 12 bars/hour)
bars_per_day = 78
dates = sorted(set(ret_hf.index.date))
rolling_ll = []
for d in dates:
day_data = ret_hf[ret_hf.index.date == d]
if len(day_data) < 20:
continue
x = day_data['NVDA'].values
y = day_data['AMD'].values
# lag-1: NVDA at t-1 predicts AMD at t
corr_lag1 = np.corrcoef(x[:-1], y[1:])[0, 1]
rolling_ll.append({'date': pd.Timestamp(d), 'lag1_corr': corr_lag1})
rolling_ll_df = pd.DataFrame(rolling_ll).set_index('date')
# Smooth with 5-day MA
rolling_ll_df['smooth'] = rolling_ll_df['lag1_corr'].rolling(5, center=True).mean()
fig, ax = plt.subplots(figsize=(13, 4))
ax.bar(rolling_ll_df.index, rolling_ll_df['lag1_corr'], color='steelblue', alpha=0.4, width=1, label='Daily lag-1 corr')
ax.plot(rolling_ll_df.index, rolling_ll_df['smooth'], color='red', lw=1.8, label='5-day MA')
ax.axhline(0, color='black', lw=0.5)
ax.set_title('Rolling Daily Lead-Lag (NVDA lag-1 → AMD)\nStrength of 5-min Lead-Lag Effect Over Time', fontsize=12)
ax.set_ylabel('Lag-1 Correlation')
ax.legend()
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d'))
plt.xticks(rotation=30)
plt.tight_layout()
plt.show()
Granger causality at the daily level rarely reaches significance (Section 8 of the previous post). At 5-minute resolution — where market inefficiency is more exploitable — the result is often reversed.
# Use a subset to keep computation fast: one full trading week
week_data = ret_hf[ret_hf.index >= ret_hf.index[-1] - pd.Timedelta(days=7)]
pairs_gc = [('NVDA', 'AMD'), ('AMD', 'NVDA'), ('NVDA', 'MU'), ('MU', 'NVDA')]
gc_results = []
for cause, effect in pairs_gc:
data = week_data[[effect, cause]].dropna()
test = grangercausalitytests(data, maxlag=5, verbose=False)
min_p = min(test[lag][0]['ssr_ftest'][1] for lag in range(1, 6))
best_lag = min(range(1, 6), key=lambda l: test[l][0]['ssr_ftest'][1])
gc_results.append({
'Cause → Effect': f'{names[cause]} → {names[effect]}',
'Min p-value': round(min_p, 4),
'Best lag (bars)': best_lag,
'Significant (5%)': 'Yes ✓' if min_p < 0.05 else 'No',
})
gc_df = pd.DataFrame(gc_results)
gc_df| Cause → Effect | Min p-value | Best lag (bars) | Significant (5%) | |
|---|---|---|---|---|
| 0 | NVIDIA → AMD | 0.2909 | 4 | No |
| 1 | AMD → NVIDIA | 0.7751 | 1 | No |
| 2 | NVIDIA → Micron | 0.0393 | 2 | Yes ✓ |
| 3 | Micron → NVIDIA | 0.2645 | 4 | No |
Interpretation: Unlike daily data, 5-minute Granger causality tests often reject the null for at least one direction in related semiconductor pairs, confirming that short-term predictive precedence exists at intraday resolution.
A distinctive feature of individual stock returns at very high frequency (tick or 1-minute level) is negative first-order autocorrelation. This is caused by the bid-ask bounce:
At 5-minute intervals the bounce is averaged out, but the effect is still detectable in volatile stocks.
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
for ax, ticker in zip(axes, ['NVDA', 'AMD']):
r = ret_hf[ticker].values
n = len(r)
conf = 1.96 / np.sqrt(n)
lags_ac = np.arange(0, 21)
acf_vals = [1.0] + [np.corrcoef(r[:-k], r[k:])[0, 1] for k in range(1, 21)]
colors_ac = ['tomato' if (abs(v) > conf and k > 0) else 'steelblue'
for k, v in zip(lags_ac, acf_vals)]
ax.bar(lags_ac, acf_vals, color=colors_ac, width=0.7)
ax.axhline( conf, color='black', linestyle='--', lw=0.8)
ax.axhline(-conf, color='black', linestyle='--', lw=0.8)
ax.axhline(0, color='black', lw=0.5)
ax.set_title(f'ACF of 5-Min Log Returns: {names[ticker]}', fontsize=11)
ax.set_xlabel('Lag (5-min bars)')
ax.set_ylabel('Autocorrelation')
plt.suptitle('Autocorrelation at High Frequency\n(Negative lag-1 = bid-ask bounce signature)', fontsize=12, y=1.02)
plt.tight_layout()
plt.show()
Note: Negative autocorrelation at lag-1 is a hallmark of microstructure noise. It diminishes as the sampling interval grows and effectively disappears at daily resolution.
summary = pd.DataFrame({
'Property': [
'Contemporaneous correlation',
'Lag-1 cross-correlation (significant?)',
'Negative ACF at lag-1 (bid-ask bounce)',
'Granger causality (significant?)',
'Efficient market hypothesis holds?',
'Lead-lag interpretable as price discovery?',
],
'Daily data': [
'High (0.7–0.9)',
'Rarely',
'No',
'Rarely',
'Usually yes',
'No — noise-dominated',
],
'5-minute data': [
'Moderate (Epps effect)',
'Often',
'Yes (microstructure noise)',
'Often',
'Partially',
'Yes — measurable',
],
})
summary.set_index('Property', inplace=True)
summary| Daily data | 5-minute data | |
|---|---|---|
| Property | ||
| Contemporaneous correlation | High (0.7–0.9) | Moderate (Epps effect) |
| Lag-1 cross-correlation (significant?) | Rarely | Often |
| Negative ACF at lag-1 (bid-ask bounce) | No | Yes (microstructure noise) |
| Granger causality (significant?) | Rarely | Often |
| Efficient market hypothesis holds? | Usually yes | Partially |
| Lead-lag interpretable as price discovery? | No — noise-dominated | Yes — measurable |
| Concept | Daily | 5-minute |
|---|---|---|
| Contemporaneous correlation | High | Lower (Epps effect) |
| Lead-lag CCF | Flat (noise) | Peaks at 1–5 bar lags |
| Granger causality | Usually fails | Often significant |
| Autocorrelation | Near zero | Negative at lag-1 |
| Market efficiency | Holds | Partial — price discovery visible |
Summary findings: