Choosing the Block Length in Dependent Bootstraps

Ordinary bootstrap resampling draws individual observations with replacement, which works fine when observations are independent — shuffling and redrawing single points doesn't destroy anything, since there was no structure between points to begin with. But financial time series are autocorrelated: volatility clusters, returns show momentum or mean-reversion at short horizons, and drawing single days independently completely destroys that structure, since a resampled sequence of independently-drawn days has no memory of which day followed which in reality. The block bootstrap fixes this by resampling whole contiguous blocks of consecutive observations instead of single points — but this only works if you pick a sensible block length, and getting that length wrong breaks the method in one of two distinct, opposite ways.

An analogy: reassembling a song from clips, not individual notes

Imagine trying to recreate the feel of a song by cutting it into pieces and rearranging them. If you cut it into individual notes and shuffle them randomly, you get noise — all the musical structure (which note follows which) is destroyed, exactly the way independent-observation bootstrapping destroys autocorrelation. If instead you cut the song into short phrases — a few bars each — and rearrange those, you preserve the internal feel of each phrase (its local melody, its rhythm) even though the overall song no longer makes long-range sense. Cut the song into pieces that are too short, and each little phrase is nearly meaningless in isolation, barely different from single notes. Cut it into pieces that are too long, and you'll only ever have one or two clips to choose from, so your rearranged versions barely differ from the original — you haven't actually captured variability, just repeated the same one or two phrases.

The tradeoff, one symbol at a time

Let $b$ be the block length — the number of consecutive time-series observations grouped into a single resampling unit. The moving block bootstrap with sample size $n$ constructs overlapping blocks of length $b$ starting at each possible position, then builds a resampled series of length $n$ by drawing (with replacement) roughly $n/b$ of these blocks and concatenating them.

The tradeoff is a classic bias-variance tension in the block length itself:

• Too short a block ($b$ small) fails to capture the true autocorrelation structure — any dependence between observations more than $b$ steps apart is severed at every block boundary, so the resampled series understates genuine persistence (e.g., in volatility clustering that lasts many days), biasing standard error estimates downward.
• Too long a block ($b$ large, approaching $n$) means there are very few distinct blocks to draw from — with $b$ close to $n$, there might be only a handful of usable starting positions, so resampled series barely differ from each other or from the original data, understating the true sampling variability and giving overconfident (too narrow) intervals.

The standard guidance, formalized in optimal block-length theory, is that $b$ should grow with $n$ but much more slowly — typically on the order of $b \propto n^{1/3}$ for a variance estimate, tuned to the decay rate of the series' own autocorrelation: a series with long-memory dependence needs a longer block than one that decorrelates quickly.

Worked example: block length for a momentum strategy's Sharpe ratio

Suppose you're bootstrapping the standard error of a momentum strategy's Sharpe ratio using 1,000 days of daily returns that show meaningful autocorrelation up to about 10 trading days (a typical momentum decay horizon). Choosing $b = 1$ (single-day blocks, equivalent to the ordinary i.i.d. bootstrap) ignores this entirely — the resampled return sequences have none of the real 10-day dependence structure, and the bootstrap standard error comes out smaller than the truth, because random daily shuffling accidentally cancels out streaks that in reality tend to persist. Choosing $b = 20$ (roughly twice the dependence horizon) captures the 10-day autocorrelation reasonably well within each block while still allowing $1000/20 = 50$ distinct blocks to combine into varied resampled sequences. Choosing $b = 500$ (half the sample) would leave only 2 non-overlapping blocks worth of genuinely distinct information — resampled sequences would essentially just be reshuffled halves of the original data, drastically understating true variability.

The explorer below simulates random paths and lets you compare mean-reverting versus trending dynamics — switching between them is a quick way to build intuition for how long a series' "memory" lasts, which is exactly the horizon the block length needs to match.

Worked example: comparing standard error estimates directly

Suppose the true (population) standard error of the Sharpe ratio estimate is known, from theory, to be about 0.18. Bootstrapping with $b=1$ on the 1,000-day sample yields an estimated standard error of 0.11 — too small, because ignoring the 10-day autocorrelation makes returns look more independent (and therefore more "averaged out" and precise) than they really are. Bootstrapping with $b=20$ yields 0.17, much closer to the true value, since blocks of 20 days preserve most of the real dependence. Bootstrapping with $b=250$ (four blocks total) yields an unstable estimate that varies wildly between 0.09 and 0.31 across different bootstrap runs, since there are too few distinct blocks to draw a representative resample from.

What this means in practice

Block length choice matters for any bootstrap applied to autocorrelated financial data: standard errors on Sharpe ratios, drawdown statistics, backtested strategy performance, or any resampling-based confidence interval on a time series with genuine memory (see block bootstrap of returns). Practitioners typically use data-driven rules (like the Politis-White automatic block-length selector, which estimates the series' own autocorrelation decay and picks $b$ accordingly) rather than a fixed guess, and often check robustness by trying a few different block lengths and confirming the answer doesn't swing wildly — if it does, that itself is a warning sign that the chosen range of $b$ is poorly matched to the data's dependence structure.