77 terms, each with where it breaks.

Alpha, in its classical Jensen’s-alpha form, is the intercept from regressing a portfolio’s returns on a benchmark’s: the annualised return left over after removing whatever the portfolio’s beta exposure to the benchmark already explains. A positive alpha means the portfolio outperformed what its market exposure alone would predict; a negative one means it underperformed even after accounting for the risk it took relative to the benchmark.

The measure inherits every assumption behind the regression used to estimate it — that the relationship with the benchmark is linear and stable, and that the benchmark itself is the right comparison. An alpha estimated over a short window is noisy, since it is the difference between two estimated quantities rather than a directly observed one, and a genuinely skilled result can be indistinguishable from a lucky one without a validation design that tests whether the same edge persists out of sample. Alpha also says nothing about how many strategies were tried before this one was reported — that correction belongs to multiple-testing adjustments, not to the alpha estimate itself.

Anomaly detection identifies observations that differ substantially from the rest of a dataset, without being trained on a labelled set of known anomalies — a method like isolation forest works by measuring how easily an observation can be separated from the rest of the data through random partitioning, on the logic that outliers require fewer partitions to isolate. Local outlier factor and one-class SVM take different approaches to the same underlying question: how unusual is this observation relative to its neighbours or relative to the bulk of the training distribution.

Because there is no ground truth for what counts as anomalous, the method’s output has to be validated by domain judgement rather than a held-out accuracy score — a flagged observation might be a genuine data error, a real but rare market event, or simply a point in a region the training data under-sampled. The choice of contamination rate, or how many observations a method is tuned to flag, is itself a judgement call with no universally correct answer, and changing it can move the same dataset from flagging almost nothing to flagging a substantial fraction of all observations.

ARIMA combines three components into one model: an autoregressive term expressing the current value as a function of its own past values, a moving-average term expressing it as a function of past forecast errors, and a differencing step applied enough times to render a non-stationary series stationary before the other two components are fit. The seasonal extension, SARIMA, adds the same structure at a seasonal lag, useful for series with a regular recurring pattern beyond simple short-run autocorrelation.

Choosing an ARIMA model’s order — how many autoregressive terms, how much differencing, how many moving-average terms — is itself a modelling decision usually guided by autocorrelation diagnostics, and a poorly chosen order can fit the training sample well while forecasting poorly. ARIMA also assumes the differenced series is genuinely stationary and that its errors are not conditionally heteroskedastic; when volatility clusters, as it typically does in financial returns, an ARIMA model for the mean is often paired with a separate GARCH model for the variance rather than expected to capture both on its own.

An audit trail is a chronological record of every action, run and artifact a research project has produced, each entry traceable back to the specific project and page that generated it. It answers the question a trial ledger and a content hash cannot answer alone — not just which configurations were tried, but the full sequence of what a researcher actually did, in the order they did it, across the whole life of a project rather than one specific line of investigation.

An audit trail is most valuable precisely when a result is being questioned: a number reported months later can be traced back through the log to the exact run, the parameters in force, and the sequence of steps that produced it, rather than relying on a researcher’s memory of what they did. This is why the log is read-only by design rather than an editable history — a log that can be revised after the fact provides no stronger a guarantee than no log at all, since either way there is no way to know whether what is shown reflects what actually happened.

A backtest replays a trading strategy’s rules against historical price data to estimate how it would have performed, applying assumed transaction costs, slippage and, where relevant, borrowing costs for short positions. A vectorised backtest computes the resulting equity curve quickly by assuming fills occur at the modelled price; an event-driven backtest processes each bar with an order queue and a cash ledger, which is the only design capable of modelling partial or missed fills rather than assuming every trade executes as instructed.

A backtest is only as good as its assumptions about costs and its discipline about what information a rule could actually have used at each point in time — an otherwise correct simulation that ignores transaction costs, or that lets a rule react to information from later in the same bar, reports a result no live implementation could reproduce. A backtest also always describes the past: it estimates how a strategy would have performed on the exact history supplied, and it is silent about how much of that performance depended on features of that specific history that will not recur.

A benchmark is the comparison point a result is judged against: an index for a long-only equity strategy, a risk-free rate for an absolute-return one, or a simple equal-weight allocation for a portfolio construction method claiming to add value through optimisation. A 9% annual return means something different depending on whether the benchmark returned 4% or 14% over the same period, which is why quantitative research states its comparison point before describing a result as good or bad, rather than after.

The choice of benchmark is itself a claim, and changing it after seeing results — picking whichever index makes a strategy look strongest — quietly substitutes a favourable comparison for an honest one. A benchmark also has to be genuinely investable and available over the same period as the strategy it is compared against; a benchmark constructed with the benefit of hindsight, such as an index whose constituents are chosen using information not available at the time, produces a comparison that flatters the strategy without saying so.

Beta measures how much a security or portfolio tends to move for a given move in a benchmark, estimated as the covariance between the two return series divided by the benchmark’s own variance. A beta of 1.2 means the position has historically moved roughly 20% more than the benchmark in the same direction; a beta near zero means the position’s returns have shown little linear relationship with the benchmark at all. Beta is the input that scenario and stress-testing tools use to propagate a hypothetical market move through every asset in a portfolio.

The estimate assumes the linear relationship between a position and its benchmark is stable over the window used to fit it, which is rarely true across a full market cycle — beta measured in a calm period can differ substantially from beta measured during a crisis, when correlations across assets tend to rise together. Beta also captures only the linear component of a relationship; a security whose sensitivity to the benchmark changes with the benchmark’s own level, as an option’s does, is poorly described by a single beta number.

The Black-Litterman model starts from the expected returns implied by current market-capitalisation weights under equilibrium — what the market must already believe, given how it is priced today — and blends that starting point with an investor’s explicit views, each carrying a stated confidence level. The result is a set of expected returns less extreme and less noisy than either the equilibrium returns alone or a set of views imposed without any anchor, which in turn produces more stable portfolio weights than feeding raw historical expected returns directly into mean-variance optimisation.

Following the model’s original He and Litterman (1999) formulation, the parameter often described as controlling how much weight the prior receives relative to the views cancels out of the posterior return calculation entirely when the same scaling is applied consistently to both the equilibrium uncertainty and the views’ own uncertainty — what actually controls the blend is the confidence assigned to each individual view, not that separate scaling parameter. A model or interface that suggests otherwise is describing the mathematics incorrectly, whatever the slider appears to do.

Securities in a universe do not always share an identical trading calendar — different listing exchanges observe different holidays, and a thinly traded name can have days with no recorded trade at all. Calendar alignment restricts a dataset to the set of dates every security in the universe genuinely traded on, so a cross-sectional calculation on any given date is comparing values that all actually exist, rather than silently forward-filling or dropping individual names on an inconsistent, per-security basis.

The trade-off is direct: the more securities in a universe, and the more heterogeneous their trading calendars, the more dates alignment removes, which shrinks the effective sample available to every downstream calculation. A calendar alignment step should warn once the row removal crosses a material threshold — losing more than a quarter of the calendar’s dates to align a universe is usually a sign that one or two illiquid names are dictating what the entire universe can see, and are better handled by exclusion than by forcing the whole universe onto their sparse calendar.

Calibration measures whether a model’s predicted probabilities correspond to real-world frequencies: among all the observations where a classifier predicted a 70% chance of an outcome, did that outcome actually occur about 70% of the time? A model can rank observations well — a high ROC AUC — while being poorly calibrated, consistently overstating or understating its own confidence, because ranking ability and calibration are different properties and a model is not automatically good at both.

Calibration matters most when a predicted probability is used directly, rather than just its rank — sizing a position by a model’s stated confidence, for instance, depends on that confidence being trustworthy in an absolute sense, not merely useful for ordering candidates. Calibration is typically checked with a reliability diagram, plotting predicted probability against observed frequency in bins, and it can degrade even for an otherwise well-performing model when the class balance of the deployment data drifts away from the class balance the model was trained on.

The Calmar ratio compares a strategy’s compound annual growth rate against the worst peak-to-trough decline it suffered getting there. Unlike the Sharpe ratio, it uses drawdown rather than volatility as its risk term, which makes it sensitive to the single worst period in the sample rather than to dispersion across the whole series. Growth has to be measured by compounding, not by an arithmetic average of periodic returns — the two diverge sharply once a series includes any large loss, since a compounding calculation reflects that a loss followed by an equal-sized gain does not return a portfolio to its starting value.

The ratio assumes the historical maximum drawdown is representative of future tail risk, which a short or lucky sample rarely guarantees. It is unstable on short track records, where one bad month can dominate the denominator, and it says nothing about how often drawdowns of that size recur. In the workspace’s own catalogue this measure is currently marked unverified: it is implemented and reported, but no reference case has yet been checked against it.

Classification is the supervised learning task of assigning each observation to one of a fixed, discrete set of categories — commonly a binary up-or-down direction, but also multi-class regime labels or the outcome of a triple-barrier label such as profit-take, stop-loss or expiry. A classifier’s output is typically a probability for each class, which is then compared against a chosen threshold to produce a final decision, and ROC AUC evaluates the ranking of those probabilities across every possible threshold at once.

Classification in finance carries two assumptions worth stating plainly: that the classes are meaningfully separable given the available features at all, and that the class balance in the training sample resembles what will actually be seen going forward. A market that moves up on 55% of days produces a naive baseline that already scores 55% accuracy without learning anything, which is why classification results should always be reported against that baseline and against the worst fold of a proper out-of-sample evaluation, not against accuracy alone.

Clustering groups observations — securities, time periods, return patterns — by similarity, without a labelled answer key telling the algorithm what the correct groups are. K-means partitions observations into a fixed number of groups by distance to a group centre; hierarchical clustering builds a nested tree of groupings that can be cut at any desired number of clusters; density-based methods like DBSCAN find groups of arbitrary shape and explicitly leave some points unassigned as outliers rather than forcing every observation into a cluster.

Because clustering has no ground truth to validate against, its output has to be assessed differently from a supervised model: does the grouping make economic sense, is it stable when the data is perturbed slightly, and does a chosen number of clusters actually reflect real structure rather than an arbitrary parameter choice? Clustering securities by return-history distance is one of the building blocks behind hierarchical risk parity, where the clustering tree determines how portfolio risk is allocated rather than being an end in itself.

Two series can each be non-stationary — trending, wandering, with no fixed mean — while some linear combination of them is stationary, oscillating around a fixed level rather than drifting indefinitely. That combination is a cointegrating relationship, and it is the basis of pairs and spread trading: rather than betting on the direction of either series alone, a strategy bets on the spread between them reverting to its historical mean. The Engle-Granger two-step test estimates the hedge ratio between two series and then tests whether the resulting spread is stationary; the Johansen test extends the idea to more than two series at once, testing for the rank of the cointegrating relationship among them.

Cointegration is a property of a specific historical sample and a specific estimated hedge ratio, and neither is guaranteed to hold going forward — a relationship that was cointegrated over one period can break down structurally, at which point a spread that previously reverted to its mean can drift indefinitely instead, the central risk in any pairs trade. Testing for cointegration also assumes the individual series are themselves non-stationary in the first place, which should be confirmed with a stationarity test before a cointegration test is run, not assumed from the nature of the assets involved.

Combinatorial purged cross-validation (CPCV) divides a series into N time groups and evaluates every combination of k groups held out as a test set, purging and embargoing each boundary. Rather than one train/test split or one walk-forward sequence, it produces C(N, k) splits, which can be recombined into a smaller number of independent backtest paths — a default configuration of six groups and two held out produces 15 splits but only five independent paths, because splits sharing test groups are not independent observations of the strategy’s performance.

That distinction matters for how the results can honestly be described: reporting “15 out-of-sample paths” from a (6, 2) configuration would count each underlying observation roughly three times over and overstate how much independent evidence exists. CPCV assumes the time groups it works with are wide enough that purging and embargoing meaningfully separate them; on a short series with many groups, the purge and embargo gaps can consume most of the usable data before a single fold is evaluated. Stitching a coherent path also fails, deliberately, if a split produces a series of the wrong length or the underlying mode is not genuinely combinatorial.

Conditional value at risk (CVaR), also called expected shortfall, answers the question VaR leaves open: given that a loss exceeds the VaR threshold, how large is it on average? Where VaR names a boundary, CVaR averages everything beyond it, which makes it sensitive to the shape of the tail rather than just its edge. This also makes CVaR a coherent risk measure — it satisfies subadditivity, meaning the CVaR of a combined portfolio can never exceed the sum of its parts’ CVaRs, a property VaR does not guarantee.

Because CVaR averages over the tail, it requires enough tail observations, or a distributional assumption about the tail’s shape, to estimate reliably — a short sample with only a handful of extreme losses produces a noisy average from very few points. CVaR is also the natural objective for portfolio construction methods that optimise for tail risk directly rather than for variance, since minimising variance can leave a portfolio exposed to an asymmetric, fat-tailed loss that variance alone does not see.

A content hash is computed over a fixed set of an experiment’s inputs — the strategy specification and version, the dataset identifier and its own content hash, the feature set, universe, period, parameters, split design, assumptions, benchmark, seed and engine version — deliberately excluding timestamps, record identifiers and the results themselves. Two runs sharing every one of those inputs will produce an identical hash, regardless of when each was run, which lets a system recognise “this exact experiment has already been run” and flag a re-run that reports a different result under the same hash.

This is a reproducibility-detection mechanism, not a tamper-evident chain: the hash proves an experiment’s inputs match a previous one, it does not cryptographically link one experiment record to the next the way a blockchain would, and it should never be described as one. A content hash also cannot detect a change in something it was not designed to cover — a silent change to the underlying data provider’s historical values, for instance, will not be caught by a hash computed only over the dataset’s declared identifier and content hash at the time it was fetched.

The covariance matrix holds the pairwise covariance between every asset’s returns in a universe — the diagonal entries are each asset’s own variance, and the off-diagonal entries capture how pairs of assets move together. It is the single input shared by nearly every portfolio construction method: mean-variance optimisation and risk parity both use it directly, and hierarchical risk parity derives its clustering tree from the correlations it implies.

A sample covariance matrix estimated from historical returns becomes progressively less reliable as the number of assets grows relative to the number of return observations available, since the number of pairwise entries to estimate grows with the square of the asset count while the data available to estimate them grows only linearly with the sample length. This is the estimation-error problem that shrinkage estimators like Ledoit-Wolf, denoised random-matrix-theory estimators, and exponentially weighted schemes each address differently, and it is also why a genuinely ill-conditioned covariance matrix — one close to singular — should be refused or explicitly flagged for repair rather than inverted and used as if it were reliable.

The deflated Sharpe ratio (Bailey and Lopez de Prado, 2014) answers a question the ordinary Sharpe ratio cannot: given that a researcher tried N configurations and reported the best one, what is the probability that its true Sharpe ratio actually exceeds zero, once the search itself is accounted for? It raises the bar a result has to clear by an amount that grows with the number of trials, the variance across those trials, and the skew and kurtosis of the returns, since a highly skewed strategy can produce an inflated Sharpe ratio from a small number of large favourable observations.

The measure depends entirely on an honest trial count — it requires a real population of attempted configurations to deflate against, and refuses to compute rather than fabricate a plausible-looking number when no such population is supplied. This is why the number of things tried has to be tracked as the search happens, in a trial ledger, rather than reconstructed afterwards from memory. Sorting a table of candidate strategies by raw Sharpe ratio rather than by deflated Sharpe ratio is one of the most reliable ways to let the most over-searched configuration win by construction.

Degradation grades how much of a strategy’s in-sample Sharpe ratio it retains once tested out of sample, combined with how many of its out-of-sample folds turned negative. A retention of 70% or more, with fewer than a quarter of folds negative, passes; 40% or more warns; anything below that fails — three tiers rather than a single pass-fail line, because the useful information is in where along that scale a result sits, not just which side of one cutoff it falls on.

Degradation is deliberately proposed as the number that should headline a backtest report, ahead of the in-sample Sharpe ratio itself, because the in-sample figure describes how well a strategy fit the data it was built on, while degradation describes how much of that fit actually survived contact with data the strategy never saw. A strategy with an impressive in-sample Sharpe ratio and poor degradation is a strategy whose headline number is the least informative thing about it — the retention statistic is telling the more important part of the story.

Dimensionality reduction compresses a large number of correlated variables into a smaller number of components that retain as much of the original information as possible. Principal component analysis (PCA) finds orthogonal directions of maximum variance in a dataset — applied to a universe’s return panel, the first few components often capture a large share of total variation, acting as statistical factors even without any economic interpretation attached to them. Related methods extend the idea to non-linear structure: kernel PCA, independent component analysis, and t-SNE, the last mainly used for visualising high-dimensional structure in two or three dimensions rather than for feeding a downstream model.

The technique assumes the variance a method optimises for is the variance that matters for the task at hand, which is not always true — PCA finds the directions of largest variance, not necessarily the directions most predictive of a target the researcher actually cares about. Components are also linear combinations of the original variables and can be difficult to interpret economically, which is a genuine cost when a result needs to be explained to someone who was not involved in producing it, not merely a technical footnote.

Drawdown tracks how far a portfolio’s value has fallen from its highest point so far, at every point in time. Maximum drawdown is the largest such decline observed over a sample, and drawdown duration is how long the portfolio took to recover its previous peak, if it did at all. Unlike volatility, drawdown is asymmetric by construction: it only ever measures the depth of losses, never the size of gains, which makes it a closer match to how an investor actually experiences risk.

The statistic assumes the historical sample contains a representative worst case, which a short or fortunate backtest rarely provides — the true worst drawdown a strategy can produce is, by definition, always at least as bad as the worst one observed so far. It also depends on where in the series the calculation starts: a drawdown computed only from a series’ interior can miss an opening loss entirely if the calculation does not treat the first observation as a potential peak. A drawdown of zero should mean a portfolio has never fallen below a prior high, not that the calculation failed to look.

The efficient frontier is the curve traced by portfolios that offer the highest expected return achievable for a given level of risk, given a set of assets, their expected returns, and their covariance matrix. Any portfolio below the frontier is dominated — some other combination of the same assets offers more return for the same risk, or the same return for less. Points along the frontier represent different risk appetites, from a minimum-variance portfolio at one end to progressively higher-return, higher-risk combinations further along it.

The frontier depends entirely on its two inputs — expected returns and the covariance matrix — both of which are estimated from historical data and both of which carry real estimation error, especially expected returns, which are notoriously difficult to forecast reliably. A frontier built from noisy estimates can look precise while resting on inputs that would look quite different estimated over a different historical window, which is why some infeasible or unstable frontier points should be recorded with the specific reason they were rejected, rather than silently dropped as if they never existed.

An embargo removes a stated number of rows immediately following a test block before training resumes on the other side of it. Purging protects the boundary before a test period; embargoing protects the boundary after one, because financial series are serially correlated — a training row that begins just after a test period can still carry information correlated with what the test period just evaluated, letting a shadow of the test result leak into the next fold’s training set.

The embargo length is a modelling choice, distinct from the purge gap, which is fixed by the label horizon; the two are combined by taking whichever is larger as the effective gap around a boundary. Too short an embargo leaves residual serial correlation uncorrected, quietly inflating validation metrics in a way that is easy to miss because the split still looks chronologically correct. Too long an embargo discards usable training data for no benefit once the serial correlation has genuinely decayed, so the setting should be sized to the correlation structure of the data being tested, not left at a single default across every use case.

An evidence pack is the exported document assembling a research project’s results into fixed sections — universe and data, absolute and benchmark-relative risk, portfolio construction, the model, out-of-sample validation including fold count and the worst fold, the strategy backtest, and a method and limitations section. Each section renders only when the corresponding evidence was actually supplied during the project’s work, so the exported document always reflects analysis that was genuinely run rather than a template with gaps quietly filled in by inference.

An undefined statistic in an evidence pack should render as a dash rather than as zero, because reporting zero for “this quantity could not be computed” is the more damaging of the two possible errors — a zero looks like a real, specific answer, while a dash correctly signals that no answer exists yet. A well-built evidence pack also carries its own limitations section explicitly, stating what the analysis did not check and what assumptions it rested on, because a document that only states favourable findings without stating its boundaries is not evidence, it is advocacy wearing evidence’s format.

Expected shortfall is the name used in much of the regulatory and academic risk literature for the same measure described elsewhere as conditional value at risk: the average loss in the portfolio’s tail beyond the value-at-risk threshold, rather than the threshold itself. The two terms describe an identical calculation, and a reader encountering either should expect the same coherent, tail-averaging risk measure — one that rewards diversification the way ordinary VaR does not, because it satisfies subadditivity.

Because expected shortfall and conditional VaR are the same quantity under different names, everything that applies to one applies to the other: both require enough genuine tail observations, or a defensible distributional assumption about the tail, to estimate reliably, and both should be reported alongside the raw VaR threshold they extend rather than presented as a replacement for it. See conditional value at risk for the full treatment of the measure, its estimation, and where it breaks down.

A feature is any quantity derived from raw data and handed to a model as an input — a moving-average distance, a rolling volatility estimate, a valuation ratio, a cross-sectional rank. Building a feature is an act of judgement about what might matter: choosing to compute momentum with a 12-month skip-month convention rather than a plain trailing return is a hypothesis about market structure, and the model that later consumes it only tests that hypothesis, it does not generate it.

Features carry the same leakage risks as any other part of a pipeline — a rolling statistic computed using a centred window rather than a trailing one silently uses future observations, and a feature scaled using statistics from the full dataset rather than the training partition alone leaks test-period information into training. Feature selection, deciding which of many candidate features actually earn a place in a model, needs the same out-of-sample discipline as model selection itself: a feature that improves in-sample fit but adds nothing out of sample has been selected for its ability to fit noise, not for genuine predictive content.

GARCH — generalised autoregressive conditional heteroskedasticity — models a series’ variance as a function of its own recent past: today’s conditional variance depends on a weighted combination of yesterday’s variance and yesterday’s squared return shock. This captures volatility clustering directly, the well-documented tendency for large moves to be followed by more large moves and calm periods to persist, a pattern a constant-volatility assumption cannot represent at all. Asymmetric variants, such as GJR-GARCH and EGARCH, allow negative shocks to raise future volatility by more than positive shocks of the same size, matching the leverage effect commonly observed in equity markets.

Fitting a GARCH model assumes the order of the model — how many lags of past variance and past shocks it includes — is adequate for the series being modelled; a (1,1) specification, the most common default, is often sufficient for daily equity returns but can understate persistence in series with longer memory. GARCH also describes conditional variance, not the level or direction of returns, so it should be read as a volatility forecast, not a return forecast, and its output is typically an input to risk measures like VaR rather than a standalone trading signal.

Gradient boosting builds an ensemble of decision trees sequentially, where each new tree is fit to the residual error left by the trees already built, gradually reducing the overall prediction error. Implementations differ in speed and detail — histogram-based variants bin continuous features for faster training on large datasets, and XGBoost adds specific regularisation terms — but the underlying sequential-correction idea is shared across all of them. On tabular financial data, where features are structured numerical columns rather than images or text, gradient boosting is typically the strongest baseline a linear model has to beat.

The sequential structure makes gradient boosting more prone to overfitting than a single tree if left unconstrained, since later trees can begin fitting noise in the residuals rather than genuine remaining signal — learning rate, tree depth and the number of estimators are the hyperparameters that control this trade-off, and all three need tuning against a genuinely held-out validation split rather than the training data the trees were fit on. Gradient boosting models are also less directly interpretable than a single tree, which is why permutation importance and partial dependence are the usual tools for explaining what a fitted boosted model has actually learned.

Hierarchical risk parity (HRP) builds a hierarchical clustering tree from asset correlations, then allocates capital down that tree by recursively splitting risk between clusters, rather than solving a single optimisation over the full covariance matrix at once. Because it never inverts the covariance matrix, HRP sidesteps the numerical instability that mean-variance optimisation suffers when a covariance matrix is estimated from a sample not much larger than the number of assets in it, a common situation in equity portfolios spanning hundreds of names.

HRP assumes the clustering structure it builds reflects genuine, stable relationships between assets, which depends on the correlation estimate feeding the clustering step being reasonably reliable over the sample used — the same estimation-error problem mean-variance optimisation faces, applied one step earlier in the process. HRP does not use expected returns at all, which removes one major source of instability but also means it cannot express a view that one asset is expected to outperform another; it allocates purely on the basis of risk structure, not return forecasts.

The Hurst exponent estimates the long-memory behaviour of a series by measuring how its variance scales with the horizon over which it is measured. A value near 0.5 is consistent with a random walk, where variance scales linearly with horizon as ordinary diffusion would predict. A value below 0.5 indicates mean-reverting behaviour, where large moves tend to be followed by moves in the opposite direction more often than a random walk would produce; a value above 0.5 indicates trending, persistent behaviour, where moves tend to be followed by further moves in the same direction.

The estimate is sensitive to sample length and to the specific estimation method used — several exist, and they do not always agree closely on the same series, particularly over short samples where the scaling relationship the exponent depends on is itself noisily estimated. A Hurst exponent is a description of a series’ historical statistical behaviour, not a guarantee that the same behaviour continues going forward, and it should be treated as one input into a broader stationarity and mean-reversion assessment rather than a standalone verdict on tradability.

A hyperparameter is a configuration value set before training begins, rather than learned from the data during it — the maximum depth of a decision tree, the number of estimators in a forest, the learning rate of a gradient boosting model, the regularisation strength of a linear model. Hyperparameters control the trade-off between a model’s flexibility and its tendency to overfit, and searching for good values, whether by grid search or a more targeted method, is itself a modelling decision that has to respect the same out-of-sample discipline as fitting the model’s ordinary parameters.

Tuning hyperparameters on the same data used to evaluate the final model quietly reintroduces the overfitting the tuning process was meant to control — a hyperparameter search needs its own validation split, separate from the split used for the final reported result, or the reported performance reflects the search’s ability to find a configuration that fits the validation data well, rather than a genuinely better model. A useful check after tuning is whether the fit still generalises to data the search never touched at all, not merely to the validation fold the search was optimised against.

Implied volatility is the volatility input that, plugged into an option pricing model such as Black-Scholes-Merton, reproduces a specific quoted option price exactly. Because the pricing formula has no closed-form inverse for volatility, it is found numerically — root-finding methods search for the volatility value that makes the model price match the market price, refusing to return an answer when the quoted price itself violates a no-arbitrage bound the model cannot reconcile with any volatility at all.

Implied volatility reflects the market’s option pricing at a moment in time under the assumptions of whichever model produced it, rather than a direct forecast of future realised volatility, and the two frequently diverge — implied volatility tends to sit above subsequently realised volatility on average, a pattern often described as a volatility risk premium. It also depends entirely on the pricing model’s own assumptions, so an implied volatility figure computed under one model’s assumptions is not automatically comparable to one computed under a different model, or to a raw historical or GARCH-based volatility estimate constructed a different way entirely.

The information ratio measures a portfolio’s active return — its return in excess of a stated benchmark — against the volatility of that excess, known as tracking error. It is the Sharpe ratio’s counterpart for relative rather than absolute performance: instead of asking how much return a strategy earned per unit of total risk, it asks how much return a manager earned per unit of risk taken away from the benchmark’s own allocation.

The measure assumes the benchmark is the correct comparison point and that tracking error is stable enough over the sample to be a fair risk denominator. It breaks down when the benchmark choice is arbitrary or changes mid-sample, since active return and tracking error are both defined relative to it — a different benchmark can turn a strong information ratio into a weak one without the underlying portfolio changing at all. It is also unstable on short samples, where tracking error is estimated from few observations and can understate the risk actually being run.

A Kalman filter estimates an unobserved state — a series’ underlying level, or its level and trend together — recursively, updating its estimate each time a new noisy observation arrives by blending the model’s prediction with the new data, weighted by their relative uncertainty. A local-level model treats the underlying value as a slowly evolving random walk observed with noise; a local-linear-trend model adds a similarly evolving trend component. The filter’s steady-state gain, once the recursion has run long enough to stabilise, can itself be derived from the model’s noise variances via the discrete Riccati equation.

The filter’s estimate is only as good as the noise variances it is configured with — how much the underlying state is assumed to drift period to period, and how noisy the observations are assumed to be — and misspecifying either can make the filter track noise as if it were genuine signal, or smooth away genuine changes as if they were noise. Unlike ARIMA, a Kalman filter naturally handles a state that evolves at each time step and can smooth as well as filter, producing a backward-looking estimate that uses the full series rather than only the data available up to each point.

The Kelly criterion computes the position size that maximises the expected long-run growth rate of capital, given an estimated edge and the variance of the outcomes it is exposed to. Sized correctly, it grows a bankroll faster than any other fixed betting fraction over a long enough horizon; sized too aggressively — which is easy to do, because the full Kelly fraction is sensitive to estimation error in the edge itself — it produces a much rougher path with materially larger drawdowns along the way.

Because the inputs to a Kelly calculation, particularly the expected edge, are themselves estimated with error, practitioners commonly use a fraction of the full Kelly size — half-Kelly is a frequent choice — which sacrifices some long-run growth for a substantial reduction in variance and drawdown risk. The criterion also assumes bets are independent and repeated, and that the edge and its variance stay constant across the sequence of bets; a Kelly size computed from a backtested edge that decays or reverses in practice inherits none of the growth-optimality the calculation promises.

The label horizon is the number of periods ahead a label’s outcome is determined by — a one-day-forward return label has a horizon of one, a five-day-forward triple-barrier label has a horizon of up to five, depending on which barrier is actually touched first. Every label with a horizon greater than one carries information from beyond the row it is attached to, which means the last h rows of any training window always share outcome information with the first rows of the test period that follows, however the split boundary is drawn.

This is why a purge gap has to be set to at least the label horizon rather than to a smaller, more convenient value — flooring the gap at the horizon, not just at a separately configured embargo setting, closes exactly the leakage window the horizon itself creates. A label horizon greater than one also reduces the effective number of independent observations in a sample, since overlapping labels share information with their neighbours, which a validation pipeline should warn about explicitly rather than let pass unremarked.

Leakage is the general term for any route by which test-period information reaches a model before it is evaluated on that period — a scaler fit on the combined train and test sets rather than train alone, a random rather than chronological split that scatters future rows into training, shuffled training rows that erase the boundary a purge gap depends on, or a label horizon left unaccounted for in an otherwise chronological split. Look-ahead bias is one specific cause of leakage; leakage is the wider category that also includes purely mechanical mistakes in how a split or a transform is built.

The defence against leakage is structural rather than a single check: fitting every transform on the training partition alone, keeping training rows in chronological order, sizing the purge gap to the label horizon, and generating an explicit warning whenever any of those safeguards is switched off. Leakage is dangerous precisely because it does not cause a pipeline to fail — it causes a pipeline to succeed too well, reporting validation metrics that look like a genuine result but describe the model’s ability to see its own answer key rather than to generalise.

Ledoit-Wolf shrinkage estimates a covariance matrix as a weighted blend of the raw sample covariance matrix and a simpler, more structured target — often a constant-correlation or single-factor matrix — with the blending weight chosen to minimise expected estimation error. The sample covariance matrix, taken alone, fits the specific historical sample too closely when the number of assets is large relative to the number of observations; the structured target is deliberately simpler and therefore more stable, and shrinking toward it trades a small amount of bias for a meaningful reduction in variance.

The method assumes the shrinkage target is a reasonable simplification of the true covariance structure, even though it is not the true structure itself — a badly chosen target can shrink toward an assumption that fits the data poorly. Shrinkage intensity is derived from the data rather than fixed arbitrarily, which is what distinguishes it from an ad hoc blend chosen by eye, and it is one of several available covariance estimators alongside denoised random-matrix-theory approaches and exponentially weighted moving-average covariance, each suited to slightly different data conditions.

A log return is the natural logarithm of the ratio of a price to its previous value, as opposed to a simple return, which is that ratio minus one. The distinction matters for two practical reasons: log returns over consecutive periods sum to the log return over the combined period, which simple returns do not, and log returns are typically closer to normally distributed, which matters for any statistical model that assumes normality somewhere in its derivation.

Log returns are usually the correct input for statistical modelling and for time-series diagnostics, but they are not interchangeable with simple returns when the question is about actual portfolio value — the arithmetic average of a series of log returns systematically understates what an investor actually compounded, because compounding a log return back into a price involves an exponential, and the expected value of an exponential of a random variable exceeds the exponential of its expected value. Annualised return figures reported from log returns should say so explicitly, since a reader assuming simple-return arithmetic will misread the number.

Look-ahead bias occurs whenever a backtest, feature or label uses a piece of information that was not actually knowable at the moment it is applied — a restated earnings figure used on the date it originally referred to rather than the date it was actually published, an index constituent list applied retroactively to a period before the security joined the index, or a full-sample statistic like a mean or standard deviation computed once and applied to every earlier row. Each of these lets a model see a sliver of its own future.

The bias assumes correction is possible after the fact, but in practice it usually is not: once a model has been fit on data contaminated this way, no amount of later validation recovers the result that would have been produced with a genuinely point-in-time dataset. The only reliable defence is upstream — stamping every record with the date it was actually knowable, and building features and labels strictly from information available as of that date. A backtest that looks unusually strong relative to comparable published results is one of the more common symptoms of look-ahead bias having entered somewhere in the pipeline.

Mean-variance optimisation, introduced by Markowitz, chooses portfolio weights to trace out the efficient frontier: for a given target level of risk, it finds the weights that maximise expected return, using each asset’s expected return, variance, and covariance with every other asset in the universe. It is the foundation most other portfolio construction methods either build on or deliberately depart from — risk parity avoids its reliance on expected-return forecasts, and hierarchical risk parity avoids inverting the covariance matrix altogether.

The optimisation is highly sensitive to its expected-return inputs, which are estimated with far more noise than the covariance matrix, so small changes in expected-return assumptions can produce large, unstable swings in the resulting weights — a well-known practical weakness that shrinkage estimators and Black-Litterman’s blend of equilibrium returns with explicit views both exist to address. Mean-variance optimisation also assumes returns are adequately described by their mean and variance alone, which understates risk for assets or strategies with meaningfully skewed or fat-tailed return distributions, a case better served by an optimisation that targets a tail-risk measure like CVaR directly.

Meta-labelling separates two decisions that a single model often conflates: which direction to bet, and whether the bet is worth taking at all once costs are considered. A primary model decides the side — long or short — and a second model is trained only to answer whether that specific bet, given the side already chosen, produced a profitable outcome net of transaction costs. The second model’s output is the meta-label, and it acts as a filter on conviction rather than a competing direction signal.

Meta-labelling assumes the primary model’s side decisions are reasonably informative to begin with — a meta-label can improve precision by filtering out low-conviction bets from an already-sound primary signal, but it cannot manufacture edge in a direction call that carries none. It is commonly built on top of triple-barrier labelling, since the triple-barrier outcome — profit-take, stop-loss, or expiry — is a natural target for the “was this bet worth taking” question the meta-label is meant to answer, and both stages need to respect the same purge and embargo discipline as any other supervised model in the pipeline.

Minimum track record length answers a question every short backtest eventually has to face: how long does a series of returns need to run before its observed Sharpe ratio can be trusted to actually exceed a benchmark, rather than merely appearing to by chance? It is built from the same statistics as the probabilistic Sharpe ratio — the observed Sharpe ratio, its skew and kurtosis, and a target confidence level — solved for the sample length that would make that observed Sharpe ratio statistically significant at the stated confidence.

The calculation assumes the strategy’s true Sharpe ratio and return distribution stay constant over the additional period it prescribes, which is rarely guaranteed in practice — a strategy’s edge can decay well before its track record reaches the length that would have validated it. It is most useful as a discipline rather than a forecast: a strategy whose required minimum track record is far longer than the sample actually available is a strategy whose current Sharpe ratio should not yet be treated as established, however good it looks today.

Test enough variations of an idea against the same dataset — different lookback windows, different assets, different entry rules — and ordinary sampling variation guarantees that some of them will look good even if none carries a real edge. Multiple testing is the general name for this problem, and every correction for it works the same way: adjust the significance threshold, or the statistic itself, for the number of independent looks that were taken, rather than judging the winning result as if it were the only thing tried.

Corrections range from simple threshold adjustments — Bonferroni, Holm’s step-down procedure, Benjamini-Hochberg-Yekutieli control of the false discovery rate — to tests built specifically for strategy selection, such as White’s Reality Check and Hansen’s Superior Predictive Ability test, both of which evaluate the full set of tried strategies against a bootstrap-derived null rather than just the best one. Every correction assumes the trial count fed into it is complete and honest; a haircut computed from a partial or self-reported trial count corrects for less multiple testing than actually occurred, understating how weak the surviving result really is.

A naive baseline is the simplest possible prediction rule for a given task: carry the last observed value forward, predict the historical average, or always predict the majority class. It requires no fitting and no data beyond what is already at hand, which makes it the honest floor against which any more sophisticated model has to be judged. A classifier that reaches 61% accuracy sounds impressive until it is compared against a naive baseline of 60% — the majority class frequency in a market that trends up more often than down — at which point the model’s actual contribution shrinks to one percentage point.

The comparison assumes the naive baseline is computed identically to the model being evaluated — same data, same split, same period — since a baseline measured on a different window is not a fair comparison point. Skipping this comparison is one of the most common ways a research result overstates itself: a model can clear ordinary statistical significance tests and still be adding nothing once measured against the trivial rule it was implicitly competing with. A skill score, comparing model error against baseline error directly, makes this comparison explicit rather than leaving it to be inferred.

Overfitting happens when a model’s parameters, or a strategy’s rules, are tuned closely enough to the specific sample they were built on that they capture that sample’s noise rather than a relationship likely to recur. An overfit model reports excellent in-sample performance and disappointing out-of-sample performance — the gap between the two is the most direct evidence of overfitting there is, which is why it is a detection problem more than a prevention one: the only way to know overfitting has occurred is to hold out data the fitting process never saw and measure the drop.

Overfitting is not confined to complex models with many parameters; it can arise from something as simple as trying many strategy variations and reporting only the best one, which is a form of overfitting applied to a human search process rather than a numerical optimiser. The corrections for both forms overlap: walk-forward validation with a purge gap detects overfitting in a fitted model, while the deflated Sharpe ratio and probability of backtest overfitting detect it in a searched strategy space. A degradation statistic comparing in-sample and out-of-sample Sharpe retention is the single number that best summarises how much overfitting a given result carries.

A partial dependence plot shows how a model’s average prediction changes as one feature is varied across its range, while every other feature is held at the values actually observed in the data. It answers a different question from permutation importance: rather than how much a feature matters overall, it shows the shape of the relationship — whether a feature’s effect is roughly linear, has a threshold, or reverses direction somewhere in its range, information a single importance score cannot convey.

The plot assumes the feature being varied is not too strongly correlated with the others being held fixed, since varying one feature in isolation can produce combinations of feature values that never actually occur together in real data — extrapolating a model’s behaviour into a region it never saw during training. Partial dependence also averages over the whole dataset, which can obscure genuinely different relationships in different subgroups; an individual conditional expectation plot, which traces the same relationship for single observations rather than an average, is the natural complement when that heterogeneity matters.

Permutation importance estimates how much a trained model depends on a given feature by shuffling that feature’s values — breaking its relationship with the target while leaving every other feature untouched — and measuring how much the model’s out-of-sample performance degrades as a result. A feature whose shuffling causes a large drop in performance is one the model relies on heavily; a feature whose shuffling changes almost nothing is one the model has effectively ignored, whatever weight it might have been given inside the model’s internal structure.

Because it only requires the ability to make predictions and measure performance, permutation importance works identically across model families — a linear model, a random forest and a neural network can all be attributed the same way, which is what makes it model-agnostic. It assumes the features are not too strongly correlated with each other: when two features carry overlapping information, shuffling one can be partially compensated for by the other still present, understating both features’ importance in a way that a correlation-aware analysis would catch and a naive reading of the importance scores would not.

Point-in-time data carries not just what a value was, but when that value first became knowable. A company’s quarterly earnings are a common example: the figure eventually settles on a final restated number, but that number was not available on the date it originally referred to — only on the later date it was actually published, and sometimes it changes again after a subsequent restatement. Point-in-time discipline means every calculation uses the version of a fact that existed as of the date being simulated, not the version that exists today.

The concept assumes a dataset actually records publication dates, or at least a reliable lag, rather than only the values themselves — many free and even many paid data sources provide only the latter, which makes proper point-in-time handling one of the more expensive parts of building a genuinely reliable dataset. Getting it wrong is one of the most common sources of look-ahead bias, and one of the hardest to notice after the fact, because a dataset built without publication dates gives no visible sign that anything is missing.

The probabilistic Sharpe ratio (PSR) converts an observed Sharpe ratio into a probability: given the sample length and the skew and kurtosis of the return series, how likely is it that the strategy’s true Sharpe ratio exceeds a stated threshold, often zero or a benchmark’s own Sharpe ratio? Two strategies can report an identical observed Sharpe ratio and receive very different PSR values if one has a much shorter track record or much fatter-tailed returns than the other — both make the observed number a less reliable estimate of the true one.

The calculation assumes the observed skew and kurtosis are themselves reasonably estimated, which a short sample makes difficult — the higher moments a PSR calculation depends on are noisier than the mean and variance it also uses. It is also a statement about statistical significance, not economic significance: a very long track record can produce a high PSR for a Sharpe ratio too small to be worth trading. PSR is the building block behind the minimum track-record length calculation, which asks the reverse question — how long a record needs to be before a given Sharpe ratio clears a stated confidence level.

Probability of backtest overfitting (PBO) is estimated through combinatorially symmetric cross-validation (Bailey, Borwein, Lopez de Prado and Zhu, 2015): the full set of trial return series is split repeatedly into complementary in-sample and out-of-sample groups, the best-performing configuration in each in-sample group is identified, and PBO is the fraction of splits in which that in-sample winner ranks below the median out of sample. A high PBO means the selection process is picking configurations that look good only because of how they fit the specific sample searched, not because they carry a real edge.

The method needs a genuine population of trial results to split — it cannot be computed from a single reported configuration, only from the full set that was searched to find it, which is why it depends on the same honest trial-tracking that the deflated Sharpe ratio requires. Its default configuration groups trials into 16 subsets and caps the number of combinations evaluated with deterministic sampling above that cap, trading exhaustive coverage for a tractable, repeatable computation on large trial populations.

Provenance is the recorded origin of a piece of data or a result: which provider supplied it, what content hash identifies its exact contents, what parameters or transformations were applied to produce it, and who or what process initiated the run. It is the connective information that turns a bare number into something that can be checked — a Sharpe ratio without provenance is a claim; the same Sharpe ratio with its dataset, parameters and method recorded is a checkable result.

Provenance has to be captured at the point a dataset or result is created, not reconstructed afterwards, because reconstruction relies on memory and inference rather than a record — a dataset fetched without noting its provider, retrieval date and any applied adjustments cannot have that information added back accurately later. Provenance also underpins staleness detection: an evidence block’s stored fingerprint is what lets a system recognise, later, whether the source it was built from has since been re-run with different results.

A label built from prices between day t and day t+h is not fully known until day t+h arrives. Purging removes any training row whose label window overlaps the test period that follows it, so the model is never fit on an observation whose outcome was determined by information the test period is meant to be blind to. The purge gap is set to the label horizon, not to a smaller convenience value, because the last h training rows always share their outcome with the first test rows regardless of what a purge setting says on the surface.

The mechanism assumes the label horizon is correctly stated — a workflow that computes a five-day-forward label but purges only one day of gap has not purged at all in the region that matters. It breaks silently rather than loudly: a validation split without an adequate purge gap still runs, still reports metrics, and those metrics still look plausible, which is exactly why the gap needs to be enforced as a pipeline default rather than left to a researcher’s judgement on each run.

A random forest trains many decision trees independently, each on a bootstrapped sample of the training data and a random subset of features at each split, then averages their predictions for regression or takes a majority vote for classification. The randomness in both the data sample and the feature subset decorrelates the individual trees, so their combined average has lower variance than any single tree would, without requiring the careful sequential tuning gradient boosting needs.

Random forests are relatively robust to unscaled features and to a mix of continuous and categorical variables, and they resist overfitting better than a single deep tree, though they are not immune to it — enough trees fit to a genuinely noisy target will still overfit the noise on average, just more slowly than a single tree would. They tend to underperform gradient boosting on problems with a strong, smooth underlying signal, but their relative stability and lower sensitivity to hyperparameter choices make them a reasonable first model to try before investing time in a more carefully tuned boosted alternative.

Regression is the supervised learning task of predicting a continuous numerical quantity — next-period return, realised volatility, a spread level — rather than a discrete category. Its outputs are typically evaluated with R-squared, root mean squared error, and directional accuracy, the last of which checks how often the predicted sign matches the realised sign even when the magnitude is off, since a return forecast that gets the direction right but the size wrong can still be useful for a trading rule built on direction alone.

A regression model assumes the relationship between its features and the target is learnable from the training sample and stable enough to hold out of sample, an assumption financial data tests harder than most domains because the underlying relationship between predictors and returns is often weak and unstable through time. R-squared in particular can be misleadingly close to zero for a genuinely useful financial model, since even a modest, persistent edge in a noisy return series produces a small percentage of explained variance — comparing against a naive baseline via a skill score is usually more informative than the raw R-squared figure on its own.

A result is reproducible when someone other than the person who produced it — or the same person, months later — can regenerate it exactly from what was recorded: the dataset and its content hash, the parameters used, the code and library versions, any random seed, and the methodology, including the split design, embargo settings and stated assumptions. A reproducibility checklist covering each of these items, unweighted and without a composite score, is a more honest signal than a single “reproducibility rating,” because a result missing even one item — an unrecorded seed, an undocumented assumption — cannot actually be regenerated regardless of how many other items were captured correctly.

Reproducibility is a precondition for trusting a number months or years after it was produced, not a formality performed once and then forgotten — a number that cannot be traced back to the exact conditions that produced it is a number that cannot be defended later, however carefully it was computed the first time. It is distinct from correctness: a result can be perfectly reproducible and still wrong, if the method itself contained an error, which is why reproducibility and validation are separate, complementary checks rather than substitutes for one another.

Risk parity sets portfolio weights so that every asset contributes an equal share of total portfolio risk, rather than an equal share of capital the way an equal-weight portfolio does. Because lower-volatility assets need a larger capital weight to contribute the same amount of risk as a higher-volatility one, risk parity portfolios typically hold more of low-volatility assets like bonds and less of high-volatility assets like equities than a naive equal-weight or capital-weighted portfolio would, unless leverage is applied to bring overall portfolio risk back up to a target level.

The method depends on the covariance matrix used to estimate each asset’s risk contribution, and its equal risk-contribution logic assumes those contributions are stable enough over the holding period to remain roughly balanced — a correlation regime shift, particularly a rise in correlations during a market stress episode, can concentrate realised risk in ways the original weighting did not anticipate. Risk parity, like hierarchical risk parity, uses no expected-return forecast, which makes it a genuinely different construction philosophy from mean-variance optimisation rather than a variant of it.

ROC AUC summarises a classifier’s ability to rank positive cases above negative ones across every possible decision threshold, rather than at just one. A value of 0.5 means the classifier ranks no better than random guessing; 1.0 means it ranks every positive case above every negative case. Because it aggregates across thresholds, ROC AUC is useful for comparing models before a specific decision threshold has been chosen, and it is the metric reported per fold in walk-forward validation for classification tasks.

The measure assumes the cost of a false positive and a false negative are roughly comparable, which is rarely true in a trading context where missing a rare large move and acting wrongly on noise carry very different costs — a metric like precision or a threshold-specific confusion matrix is often more informative once a real decision rule is being built. ROC AUC can also look respectable on average while a single fold performs close to random, which is why the worst fold across a walk-forward evaluation, not just the mean ROC AUC, is the number that should carry the headline.

The Sharpe ratio divides a portfolio’s mean excess return over the risk-free rate by the standard deviation of that return, both annualised to the same frequency. It answers one question: how much return did this strategy produce for each unit of volatility it carried along the way. Two strategies with the same average return can have very different Sharpe ratios if one arrived at that return smoothly and the other lurched through large swings to get there.

The statistic assumes that volatility is a fair proxy for risk and that returns are close enough to normally distributed for the ratio to be comparable across strategies. Both assumptions break in the same places. Sharpe penalises upside and downside volatility identically, so a strategy with occasional large gains and no large losses scores no better than one with the reverse. It is undefined when volatility is zero, and it says nothing about how many configurations were searched before this one was reported — that correction belongs to the deflated Sharpe ratio, not to this number alone.

A snapshot captures one panel or page’s rendered output at a specific moment — its markup or an image, the parameters in force at the time, the underlying figures, and provenance such as the project, route and timestamp it came from. Reopening a snapshot displays that frozen capture; it does not repopulate the original page’s controls, and it does not re-run anything, which is a deliberate distinction from a live view of the same panel that would reflect whatever the project’s data or parameters are today.

Because a snapshot is frozen, its captured values cannot be edited after the fact — only its title, folder and an accompanying note can be changed — since allowing an edit to a captured figure would make the snapshot indistinguishable from a fabricated one. Stored content is also checked against executable markup before it is accepted, so a snapshot cannot become a vector for injecting a script into a page that later displays it. A snapshot answers “what did this look like on this date,” not “what does this look like now” — confusing the two is the most common way a snapshot gets misread.

The Sortino ratio is built the same way as the Sharpe ratio, but its denominator is downside deviation — the standard deviation computed only from returns that fall below a target, usually zero or the risk-free rate. The idea is that an investor rarely objects to volatility on the upside; what matters is the dispersion of the losses. A strategy that swings widely upward but rarely falls below its target reads far better under Sortino than under Sharpe.

The measure assumes downside deviation is a meaningful description of the risk an investor actually cares about, and that enough below-target observations exist to estimate it reliably. It breaks down on short samples with few or no downside periods, where the denominator becomes small or undefined and the ratio swings wildly on a handful of observations. It also depends on the choice of target return: changing the threshold from zero to the risk-free rate can move the ratio meaningfully, and that choice should always be stated alongside the number.

Staleness describes an evidence block — a table, a chart, a figure inside an assembled report — whose underlying source has since been re-run and produced a different result than the one the block currently displays. Rather than silently updating the displayed number to match the new run, or silently leaving the old number in place with no indication anything changed, a staleness-aware system marks the block explicitly: current when it matches its source, stale when the source has moved on, and unavailable when the source was never loaded in the current session at all.

The distinction matters because an author assembling a report from many individual results needs to know which numbers still reflect the analysis they intended to cite and which have quietly drifted because an upstream step was re-run with different data or parameters. Refreshing a stale block should always be a manual, visible action rather than an automatic one — a number silently swapped underneath an author between the time they wrote a sentence about it and the time they exported the document would undermine the entire point of an evidence trail.

A stationary series has a mean, variance and autocorrelation structure that stay constant through time, rather than drifting or trending. Most statistical models used in finance — ARIMA, GARCH, cointegration tests, many machine-learning features — either assume stationarity outright or perform far better once it holds, because a model fit on one period’s statistical regime has little reason to generalise to a different one. Raw price levels are almost never stationary; log returns usually come much closer, which is one reason returns rather than prices are the typical modelling input.

Stationarity is tested rather than assumed, using tools like the augmented Dickey-Fuller test, which checks for a unit root, and the KPSS test, which checks the opposite null hypothesis, so that a series passing one but failing the other flags genuine ambiguity rather than a contradiction to explain away. A series can also be stationary in its mean but not its variance — volatility clustering is exactly this pattern — which is why stationarity checks are usually paired with a separate test for conditional heteroskedasticity rather than treated as a single verdict covering every moment of the distribution.

An ordinary bootstrap resamples individual observations independently, which is appropriate for i.i.d. data but destroys the serial dependence present in a financial time series — shuffling daily returns individually erases the volatility clustering and autocorrelation that make the series what it is. The stationary bootstrap instead resamples in blocks of random length, drawn from a geometric distribution, stitching the blocks together to build a resampled series that preserves the original series’ short-run dependence structure while still producing a genuinely different sample each time.

The method assumes the average block length is set appropriately for the dependence structure being preserved — too short and the resampled series still loses meaningful serial correlation, too long and the bootstrap produces too few effectively independent blocks to build a useful distribution of outcomes from. The stationary bootstrap underlies both the Monte Carlo path simulation used to estimate a distribution of terminal wealth and drawdown, and the multiple-testing corrections that bootstrap a null distribution across many trial strategies rather than assuming a closed-form distribution for the test statistic.

A stress test measures how a portfolio would have behaved under a specific adverse scenario, either a real historical episode replayed on the securities’ own prices for its exact dates, or a hypothetical shock propagated through each asset according to its beta and a rescaled covariance matrix. Historical replay answers “what happened to this exact portfolio during 2008 or during the 2020 crash”; a hypothetical shock answers “what would a stated market move do to this portfolio today,” and neither claims to forecast whether such an event will recur.

Historical replay is only as good as the data available to it, and it should refuse to run rather than approximate when the loaded price history does not actually cover the named episode’s dates — a stress test quietly extrapolated from partial data would misstate exactly the tail scenario it exists to illuminate. Hypothetical shocks, in turn, depend entirely on the accuracy of the beta and covariance estimates used to propagate the shock, and inherit every limitation those estimates carry, including their instability across different market regimes.

Survivorship bias appears whenever a universe is built from today’s list of constituents and applied to a historical period, silently omitting the companies that went bankrupt, were acquired, or were delisted along the way. Because the failures are missing, every statistic computed from the survivors-only universe — average return, volatility, the apparent success rate of a factor — looks better than what an investor holding the full, contemporaneous universe would actually have experienced.

The bias is easy to introduce without noticing, because a survivors-only universe still looks complete: nothing about the data signals that names are missing. Avoiding it requires the universe to be applied as it stood at each historical date, not as it stands today, which is why a research workspace should build a project’s universe from the securities selected at the point of application rather than seeding it from a preset’s current, headline constituent list. The same discipline extends to individual securities that changed composition over time — a corporate action, a spin-off, an index reclassification — each of which needs point-in-time handling for the same underlying reason.

Tracking error measures how much a portfolio’s returns deviate from its benchmark’s, computed as the annualised standard deviation of the return difference between the two. A portfolio that closely mirrors its benchmark, varying only slightly around it, has low tracking error; one that takes large active positions away from the benchmark’s own weights has high tracking error, whether or not those positions ultimately pay off. It is the risk denominator behind the information ratio, which measures active return per unit of tracking error.

Tracking error assumes the benchmark comparison is fixed and meaningful throughout the measurement period — a benchmark switched partway through a track record makes tracking error, like the information ratio built on it, difficult to interpret consistently across the full sample. It is also purely a measure of dispersion, with no direction: a portfolio that outperforms its benchmark by a wide, volatile margin and one that underperforms by the same margin can report identical tracking error, which is why the statistic is always read alongside active return rather than on its own.

A trial ledger records every configuration a researcher tries — every asset, parameter combination, and variation evaluated in the course of finding a final result — genuinely append-only, meaning there is no operation to update or delete a trial once it has been recorded, and closing the ledger blocks any further appends outright. This is what makes multiple-testing corrections like the deflated Sharpe ratio and the probability of backtest overfitting honest rather than aspirational: both require a real trial count to deflate against, and a ledger that could be edited after the fact would let that count be understated whenever it was inconvenient.

A trial ledger is only as complete as the discipline behind it — a researcher exploring ideas outside the tracked workflow, in a separate notebook or by hand, introduces trials the ledger never sees, and the resulting deflation understates how much searching actually happened. The ledger’s value comes specifically from covering the full search, including every discarded security and rejected parameter combination, not just the configurations that were formally logged as completed runs.

Triple-barrier labelling assigns each observation an outcome based on which of three conditions is met first as the position is held forward in time: an upper profit-take barrier, a lower stop-loss barrier, or a fixed holding-period expiry with no barrier touched. This produces a label that mirrors how a real position would actually be closed — by a target being hit, a stop being triggered, or time simply running out — rather than an arbitrary fixed-horizon return that ignores what would have happened to the position along the way.

The method requires choosing barrier widths and a maximum holding period before labelling begins, and those choices materially shape the resulting label distribution — narrow barriers produce more frequent profit-take and stop-loss outcomes and fewer expiries, while wide barriers do the reverse. Because the label horizon under triple-barrier labelling can vary observation by observation, up to the maximum holding period, the purge gap protecting a validation split against leakage needs to account for that maximum, not for a single fixed horizon.

A universe is the defined set of securities a research project studies — a chosen index, a custom list, or a filtered subset of either. Every downstream statistic a project produces, from a simple correlation matrix to a fully backtested strategy, inherits whatever biases and boundaries the universe carries with it, which makes the choice of universe one of the most consequential decisions in a research project, made before any model is fitted rather than adjusted after seeing results.

A new research project should begin with no universe applied by default, rather than being seeded automatically from a preset index’s current, headline constituent list — an automatically seeded universe quietly imports that index’s own survivorship bias and framing before the researcher has made any deliberate choice at all. Applying a universe explicitly also means the choice, and its known limitations — partial index coverage, a synthetic reference dataset, a provider’s specific adjustment convention — are visible and recorded as part of the project’s provenance, rather than assumed and forgotten.

Value at risk (VaR) states a single number: the loss level that a portfolio is expected to exceed only a stated fraction of the time — commonly 1% or 5% — over a stated horizon, typically one day or ten days. A 5% one-day VaR of 2% means that, under the model’s assumptions, the portfolio is expected to lose more than 2% on roughly one trading day in twenty. It can be estimated historically from past returns, parametrically from an assumed distribution, via a Cornish-Fisher adjustment for skew and kurtosis, or by Monte Carlo simulation.

VaR says nothing about how bad losses are once the threshold is breached — two portfolios can share an identical VaR while one loses barely more than the threshold in its worst cases and the other loses many times over. This is the property that makes VaR an incoherent risk measure in the technical sense: it can fail to reward diversification the way a coherent measure like conditional VaR does. It also inherits whatever is wrong with its estimation method — a historical VaR is only as representative as the historical window it was computed from.

Volatility is the standard deviation of a return series, and it is the risk term behind most of the ratios and risk measures a research workspace computes: Sharpe, VaR, position sizing and covariance-based portfolio construction all start here. Because returns are usually measured at a higher frequency than a year, volatility is annualised by multiplying the periodic standard deviation by the square root of the number of periods in a year — 252 for daily data, 52 for weekly, 12 for monthly.

The square-root scaling assumes returns are independent and identically distributed across periods, with no autocorrelation and constant variance. Real financial returns violate both: volatility clusters over time, meaning large moves tend to follow large moves, which is exactly what models like GARCH exist to capture. Simple historical volatility also treats a calm regime and a turbulent one as equally representative of the future, and it is silent about the direction of the risk it measures — a series with entirely positive surprises has the same volatility as one with entirely negative ones.

Walk-forward validation splits a time series into a sequence of folds, each with its own training window and the test period that immediately follows it, then refits the model at every new origin and moves forward. Two variants control how the training window grows: rolling keeps a fixed-length window that slides forward, while expanding keeps every prior observation and simply extends. Either way, the model is always tested on data that comes strictly after everything it was trained on.

The design assumes the relationship a model is learning is reasonably stable across the folds it is tested on — if the underlying process changes structurally partway through the sample, no fold-by-fold average will reveal that without also reporting the spread across folds. This is why the aggregate should always report the worst fold alongside the mean: a model with a strong average and one badly failing fold is a materially different result from one that performs consistently, even when the two share the same headline number. Walk-forward also needs a purge gap at least as wide as the label horizon between training and test, or the two windows share information through overlapping labels regardless of how the split looks on a calendar.

Winsorisation caps values beyond a chosen percentile — commonly the 1st and 99th — at that percentile’s value, rather than deleting the observations entirely. Applied to daily returns, a return that would otherwise sit at the extreme tail is pulled in to the boundary value, which limits the influence a single data error or genuine extreme event has on statistics like mean and variance, while preserving the row’s place in the time series so downstream calculations do not have to handle a gap.

The choice of percentile is a judgement call with real consequences: too aggressive a cutoff mutes genuine tail events that a risk model needs to see, while too loose a cutoff leaves a single bad data point free to distort every statistic computed from the series. Winsorisation also changes the actual return series being analysed, which means any statistic derived from it — volatility, Sharpe ratio, drawdown — describes the winsorised series rather than the true one, and that substitution should be stated wherever such a statistic is reported, not left implicit.

A workflow is an ordered list of steps, each naming a method from a research catalogue and the parameters bound to it, validated before it is allowed to run and versioned every time it is saved, with the previous full version retained rather than overwritten. Building a pipeline once as a workflow, rather than running each step by hand every time, means the same sequence of research decisions can be applied again to new data with the parameters and ordering preserved exactly, and every run of it becomes its own traceable record.

Validation separates problems into ones that block a run outright — an unknown method, a missing dependency, a cycle in the step ordering — from ones that only warn — a step whose declared inputs nothing earlier in the workflow actually produces. A workflow with blocking errors should never be allowed to run, because a saved workflow is something another person, or a future version of the same researcher, will pick up and run without re-checking every step by hand; a workflow that runs despite an unresolved structural problem defeats the purpose of having validated it in the first place.

When a model is evaluated across several out-of-sample folds, the mean of the fold-level metric is only one description of the result — it can conceal a run of strong folds masking one badly weak one. The worst fold is that weakest result, reported alongside the mean, standard deviation and best fold, so a reader can see the full spread rather than a single averaged number. A model with a mean ROC AUC of 0.62 and a worst fold of 0.51 is a materially riskier proposition than one with the same mean and a worst fold of 0.58, even though both would be described identically by their average alone.

Reporting only the mean assumes performance is stable across folds, which is exactly the assumption a worst-fold statistic exists to test. A wide gap between mean and worst fold suggests the underlying relationship the model is learning is not consistent across different market regimes or time periods, which matters more for a decision about whether to trust a strategy going forward than the average result from a period that has already passed.