Why finance needs it: 'the information available at time t' must be a mathematical object before adaptedness, martingales, or no-arbitrage mean anything. The filtration is why a lookahead bias is a type error, not a coding error.

Measure theory rules out pathologies that never arise in practice, and practitioners take this as evidence it is unnecessary. It is not: the whole risk-neutral apparatus is a change of measure, and you cannot change what you cannot define.

The mathematical content of risk-neutral pricing: you do not change the world, you change the probability weights so that discounted prices become martingales. Drift disappears; volatility survives. That asymmetry is the entire pricing theory.

Q exists because arbitrage does not; Q is unique because markets are complete. Both premises fail in reality, which is why incomplete-market pricing is a choice of Q, i.e. a choice of risk premium, dressed as mathematics.

American options are optimal stopping problems: V = supₜ Eᵪ[e⁻ʳₜpayoff(Sₜ)]. Optional stopping is why no betting system beats a fair game — the gambler's-ruin proof and the no-free-lunch theorem are the same theorem.

Local martingales are not martingales. The distinction is invisible in examples and decisive in bubbles: a strict local martingale price process admits arbitrage-free bubbles where put-call parity fails. Most texts skip this; the failure mode is real.

The two theorems everything rests on — and the exact conditions under which they do not hold. Financial returns have α ≈ 1.7 in many estimates: variance may not exist. Then the sample variance is not estimating anything; it is a random number that grows with n.

'It's approximately normal for large n' is a statement about the tails you have already seen. Under fat tails, convergence is so slow that no realistic sample reaches the asymptotic regime — the CLT is true and useless simultaneously.

The canonical noise. Every diffusion model is Brownian motion warped by drift and volatility functions. Scaling: Wᵀᵗ =ᵈ √a·Wᵗ — self-similarity with Hurst H = ½.

Real price paths are not Brownian: they jump, they cluster, and volatility itself has H ≈ 0.1 (rough), not ½. BM is the harmonic oscillator of finance — indispensable, and never actually the system.

The chain rule of a world where quadratic variation is nonzero. Every pricing PDE is Itô applied to a claim and then the drift set to zero by hedging. Gamma is ∂ₓₓf: the second-order term IS the option's convexity, and the source of its value.

Itô requires continuous semimartingales. With jumps you need Itô-Lévy (an extra compensated-jump integral); with rough volatility the integrator is not a semimartingale at all and you need rough-path theory. Applying vanilla Itô outside its hypotheses is the most common silent error in the literature.

The grammar in which every model in this knowledge base is written. Vasicek, CIR, Heston, SABR — all are SDEs distinguished only by their μ and σ.

√v in the CIR/Heston diffusion is not Lipschitz at zero. Existence still holds (Yamada-Watanabe), but naive Euler discretization goes negative and crashes — hence Milstein, full-truncation, and the QE scheme. The math warned you; the code found out.

The bridge between PDEs and expectations — the reason you can price by Monte Carlo *or* by finite differences and get the same number. Every 'the price is a discounted expectation' statement is this theorem being invoked silently.

The equivalence requires sufficient regularity and integrability. For payoffs with discontinuities (digitals) or unbounded growth, the naive interchange of expectation and derivative fails — which is exactly why pathwise Greeks break on digitals.

Jumps are where fat tails come from without needing stochastic volatility. Short-dated smile steepness that diffusion cannot generate is generated instantly by a jump component.

Markets with jumps are incomplete: you cannot hedge a jump with the underlying alone. The 'unique risk-neutral measure' vanishes, and every jump model's price is a choice among infinitely many Q's — a fact usually buried in the calibration.

PCA, risk factors, and portfolio optimization all reduce to eigendecomposition. Marchenko-Pastur gives the eigenvalue distribution of a *pure noise* covariance — everything inside that bulk is indistinguishable from noise.

With N assets and T observations, sample covariance is nearly singular when N/T → 1. Markowitz then inverts a matrix whose smallest eigenvalues are pure estimation error, and amplifies them by 1/λ. This is *the* mechanism behind error-maximization — not a metaphor, a condition number.

Portfolio construction, calibration, and most of ML training are convex or convexified. Mean-variance is a QP; risk parity is a convex program; SVI calibration is not convex and that is exactly why it is painful.

Convexity in the *objective* says nothing about identifiability. A flat convex valley has a unique minimum that moves violently under tiny data perturbations — Heston calibration is convexity providing false comfort.

The four identities that generate every first-order condition in portfolio theory and Gaussian likelihood. Markowitz's solution w ∝ Σ⁻¹μ falls out of the first two in one line.

Layout conventions (numerator vs denominator) transpose everything. Half the sign errors in quant papers are layout errors; the other half are forgetting that Σ is symmetric, which halves the derivative.

Any model with a known characteristic function (Heston, VG, CGMY, rough Bergomi via approximation) prices in O(N log N). This is why affine models dominate production: not accuracy, tractability.

The damping parameter α must sit inside a model-dependent admissible range or the integral diverges. Practitioners tune it by trial; the theory tells you the range. Also FFT gives a *grid* of strikes, not the strikes you want — interpolation error re-enters through the back door.

Log-volatility is empirically fBm with H ≈ 0.1 across every asset class tested. This is the single most robust empirical finding in volatility modelling since the smile itself.

fBm in the *price* admits arbitrage (that's why it was rejected in the 1990s); fBm in the *volatility* does not (volatility is not tradeable directly). The distinction took two decades to become common knowledge, and rough volatility only exists because of it.

Explains why Adam-style preconditioning works, why parameterization matters in calibration (SVI's parameters are a bad chart on a fine manifold), and gives Cramér-Rao a geometric meaning: curvature bounds estimator precision.

Beautiful, and rarely load-bearing in production. Included because it is the correct language for a question practitioners ask constantly and answer badly: 'why does my model care which coordinates I fit it in?'

The mathematical root of Kelly: maximizing E[wealth] and maximizing the growth rate of *your* wealth are different problems, and only the second is yours. It is also why volatility drag is not a fee — it is the difference between two averages.

Expected-value reasoning is the default in economics and is simply wrong for non-ergodic processes. The St. Petersburg paradox, the equity premium puzzle, and half of behavioral finance are what a time-average problem looks like when solved with ensemble tools.

The base regime map: rising/falling growth × rising/falling inflation gives four states, each favoring different assets — reflation (equities, commodities), stagflation (commodities, cash), deflation (bonds), goldilocks (equities, credit).

Regime identification is only knowable with lag; the trade is positioning for the transition, not the state. Most quadrant frameworks die at the turning points they were built to catch.

Aggregate central bank balance sheets + private credit creation + dollar funding conditions. Liquidity leads asset prices; the mechanism runs through collateral values and risk appetite, not textbook money supply.

Liquidity is measured a dozen ways and the definitions disagree at turning points — pick your gauge before the trade, not after.

Expansion → leverage builds → underwriting degrades → default cycle → deleveraging → repeat. Credit spreads are the cycle's thermometer; the corporate refinancing wall is its calendar.

The cycle is obvious in hindsight and contested in real time; spreads stay tight until they gap — carry until the steamroller.

The dollar is the world's funding currency: dollar up = global tightening for everyone who borrowed in it. EM stress, commodity weakness, and reflexivity between dollar strength and dollar demand.

Dollar cycles run years and reverse on policy divergence shifts that are only clear after the turn — the consensus dollar view is usually late-cycle.

Policy rate → funding costs → credit creation slows → asset prices reprice → wealth effect → demand → employment → inflation. Full chain runs 12–18 months; markets price the chain in weeks.

The lag is the trap: by the time hikes visibly bite, the next easing cycle is already being priced. Trading the mechanism means trading the market's model of the mechanism.

Central bank buys duration → term premium compresses → portfolio rebalancing pushes investors out the risk curve. QT reverses it — slowly, until reserve scarcity makes it fast (repo, Sep 2019).

QE's effect is contested even now; QT's floor (ample reserves) is only found by breaking something. The mechanism is discovered live, in production.

Verbal → rate policy → actual FX purchases. Effectiveness depends on whether intervention aligns with fundamentals or fights them; sterilized intervention against trend mostly burns reserves (BOJ 2022, successful only when Fed pivot aligned).

Intervention levels become market targets — announcing a line invites the test of the line. See reflexivity.

Oil up → headline inflation → inflation expectations → central bank reaction → real income squeeze → demand destruction → oil down. The loop is self-limiting; the timing of each leg is not.

Supply shocks and demand shocks look identical in price and opposite in trade construction — diagnose the shock before positioning the curve.

2s10s or 3m10y below zero has preceded every US recession since the 1960s. Mechanism: market prices future cuts below current policy = market expects the cycle to break.

The lag runs 6–24 months and the signal fires once — un-inversion (bear steepening into weakness) is historically the closer recession signal. Inversion is the warning; steepening is the event.

IG and HY spreads over treasuries: the price of default risk and the credit cycle's real-time gauge. Spreads lead equities at turns more often than the reverse.

Spread indices hide composition shifts — the index tightens while the weakest names quietly fall out of it. Survivorship inside the gauge itself.

Breakeven = nominal minus TIPS yield: the market's inflation forecast. Real rates are the true price of money — gold, tech duration, and EM all trade off real rates, not nominals.

Breakevens embed liquidity and risk premia, not pure expectation — in stress they say more about TIPS liquidity than inflation.

Above/below 50 = expansion/contraction of breadth, not magnitude. New orders minus inventories is the forward-looking spread inside the number.

Soft data diverges from hard data for quarters at a time; PMIs measure sentiment about activity, which reflexively feeds activity.

Compensation for holding duration risk beyond expected rates. Unobservable — estimated (ACM, Kim-Wright), never measured. Rising term premium = bond vigilantes repricing fiscal or inflation risk.

Every term premium model disagrees; the concept is indispensable and unmeasurable — a load-bearing fiction.

Dual mandate weighted by regime: inflation-fighting mode (2022) vs employment-protecting mode (2019). The function itself shifts — reading the Fed means reading which mandate currently dominates and what pain threshold ends it.

The reaction function is reflexive: markets price the function, the Fed reacts to market pricing of it. Fed watching is a hall of mirrors with a policy rate at the end.

Yield curve control caps JGB yields → BOJ owns the curve → yen absorbs all the pressure. The trilemma: defend the peg, defend the currency, or import inflation — pick two, and one of them breaks.

Exit from YCC is a one-way door priced in basis points until it's priced in percent. Positioning for BOJ normalization has been the widow-maker for two decades — until it wasn't.

RRR cuts, MLF, targeted lending, CNY fixing band. Quantity tools over price tools; policy transmits through state banks and window guidance, not market rates — Western central bank frameworks map poorly here.

Chinese data requires its own verification layer; the policy signal is often in what's NOT eased. See the 12-vector integrity check methodology.

Borrow low-yield currency, park in high-yield. Profits from rate differential while spot holds; the yen has funded a generation of it. Carry is short volatility by construction.

Carry unwinds are nonlinear: years of pennies, days of steamrollers. The funding currency rallies hardest exactly when everything else falls — correlation goes to one, against you.

Deficit countries import capital; the flow's composition (FDI vs portfolio vs hot money) determines fragility. Sudden stops, not deficits, cause crises.

The US deficit is sustainable until reserve currency status isn't — a threshold with no ex-ante marker. Every EM crisis playbook mispredicts the US because the funding currency writes different rules.

Commodity exporters earn dollars → recycle into treasuries and risk assets → funds the importer of the commodities. The loop's slow erosion (local-currency settlement, gold accumulation) is a decade trade, not a headline trade.

De-dollarization is structurally real and perpetually overpriced as an event — the exit is measured in basis points per year.

Size is the only variable fully under your control. Decide maximum loss per trade (in R, not dollars) before entry; conviction adjusts within that ceiling, never above it. Kelly gives the theoretical ceiling — professionals run quarter-to-half Kelly because parameter error compounds.

The account-killer is never the thesis, it's the size. Every blowup post-mortem reads the same: right idea available at survivable size, taken at unsurvivable size.

Stop distance × position size = fixed R. Wide stop, small size; tight stop, larger size — same risk. Place stops where the thesis is invalidated, not where the pain starts; a stop at 'max pain' is a donation to whoever ran it.

Moving a stop away from price is re-underwriting the trade at a worse price with worse information. If you wouldn't initiate here, you shouldn't be holding here.

Five trades that all need the dollar lower are one trade at 5x size. Aggregate exposure by driver (real rates, liquidity, growth), not by ticker. Stress the book against regime shifts, not against yesterday's covariance.

Diversification measured in calm markets is fiction — in stress, correlation goes to one precisely because everyone diversified the same way.

Pre-commit the ladder: at -5% cut gross by a third, at -10% halve it, at -15% flat and full stop for review. The ladder exists because judgment degrades exactly when it's most needed — you write the rules for the person you'll be at -12%, not the person you are today.

Trading through a drawdown 'to make it back' converts a drawdown into a career event. The market doesn't know your high-water mark.

One page: what the market misreads (misread), the mechanism that corrects it, the pressure point, the expression, and — mandatory — the falsification condition: what price or data kills it. Undated theses and unfalsifiable theses are opinions, not trades.

If you can't state what would prove you wrong, you don't have a trade — you have an identity. Identities average down.

Right view, wrong instrument is a losing trade. Rank expressions by asymmetry: options when vol is cheap relative to the scenario, futures when timing confidence is high, spreads when the relative leg is the actual insight. The best expression often survives being early; the worst dies of carry before the thesis matures.

Retail trades direction; desks trade the distribution. Paying theta for a thesis with no catalyst date is renting a house you may never occupy.

Minimum 3:1 payoff-to-risk at entry, honestly marked — using realistic exits, not fantasy targets. Convexity is the desk's structural edge: risking 1R for capped 1.5R requires a hit rate no one sustains.

Asymmetry rots silently as price moves: the 3:1 at entry is 1:1 after the first leg up. Re-underwrite or take profit — holding a decayed asymmetry is a new trade you never approved.

Enter in thirds: probe, confirm, complete — the market pays you information between tranches. Exit asymmetrically: take partials into strength at pre-set levels, trail the remainder. The goal is never the perfect exit; it's a repeatable one.

Averaging down is scaling-in's evil twin: same mechanics, opposite information regime — you're adding because the market disagrees, funded by hope.

Iceberg what must be worked; randomize slice timing; never leave a resting order that maps your full intent at one price. In thin markets your order IS the market — market impact starts before your first fill, in the information your order leaks.

Predictable execution is a subsidy to faster players. If your TWAP is guessable, it will be front-run by construction — see adverse selection.

Size executes at the opens, the closes, and the overlaps (London-NY). Off-hours fills are borrowed from tomorrow's slippage. For macro expressions, the event calendar is the liquidity calendar: CPI, FOMC, payrolls redraw the book within seconds.

The fill you get at 3am Tokyo in EURUSD is not a price — it's a quote against you. Illiquidity converts good ideas into bad P&L via pure friction.

Track implementation shortfall per trade: decision price vs achieved price. It's the desk's invisible tax — a strategy with 1.2 Sharpe on paper and 40bp round-trip slippage may be a zero. Measure it or it eats you unmeasured.

Backtests without execution costs are marketing. The gap between simulated and realized P&L is almost always execution, not signal.

Before any ticket: thesis written and falsifiable · size within R budget · correlation to existing book checked · expression ranked against alternatives · exit ladder pre-set · event calendar cleared. Sixty seconds that filter out the majority of future regrets.

The checklist's enemy is urgency. A trade that can't survive sixty seconds of process was an impulse wearing a thesis.

Log every trade: thesis, size, entry, emotional state, exit, and the honest reason for the exit. Review weekly for patterns — the journal converts anecdotes into data about the only system you can't backtest: yourself.

Un-journaled lessons repeat until the tuition is paid in size. Your memory launders your mistakes; the journal doesn't.

Separate decision quality from outcome: good process losing money is variance; bad process making money is a loan from the market at usurious interest. Post-mortem winners as hard as losers — the most dangerous trades are the undeserved wins that size up the next mistake.

Outcome bias is the desk's chronic disease: it promotes lucky recklessness and fires disciplined variance.

Pre-open: overnight moves, calendar, book risk vs plan. Session: execute the plan, log deviations. Post-close: P&L attribution — how much was thesis, how much was regime, how much was noise. The routine is boring by design; boredom is what discipline feels like from inside.

Days without structure become P&L-watching, and P&L-watching becomes over-trading. The screen rewards activity; the account rewards selectivity.

The sequence: loss → identity threat → urgent need to be made whole → size up on a worse idea. Circuit-breaker rule: after any 2R+ loss, mandatory flat period (hours, not minutes) before the next ticket. The market will still be there; the tilt won't.

Losses want repayment from the same table that took the money. The account doesn't remember where losses came from — only the ego does.

Confidence expands faster than edge. After a streak: audit whether recent wins were thesis or regime — a bull tape makes everyone's process look like alpha. Streaks are when sizing discipline earns its keep, because everything in you says the ceiling no longer applies.

More accounts die in the euphoria after the streak than in the drawdown that follows — the drawdown merely collects what euphoria borrowed.

No trade is a full allocation to optionality. When the regime is unreadable, when the book fights the calendar, when you're compromised (tired, tilted, distracted) — flat outperforms whatever you would have done. Sitting still is the hardest active decision on the desk.

The pressure to 'do something' is the P&L of others (brokers, platforms, the audience) extracted from you. Edge is episodic; exposure shouldn't be constant.

Compounding requires being present for it. Every rule above reduces to one constraint: never take a risk that removes you from the game — not in size, not in leverage, not in career terms. The trader who compounds 15% for twenty years beats almost everyone who ever printed a triple-digit year.

Tail risk applies to careers, not just books. The spectacular year and the terminal year are frequently the same year.

Every edge has a half-life: crowding, regime change, structural repair of the inefficiency. Schedule the audit — quarterly, honestly: is realized expectancy tracking the model, and what's the evidence this still works? Retiring a dead strategy is a profit, not an admission.

Strategies are defended longest by those who built them. Sunk cost plus identity is why desks run dead edges for years — see reflexivity applied to yourself.

Define the negative space: instruments you don't understand, regimes you can't read, hours you don't work, sizes you never touch. The 'no' list is more stable than the 'yes' list and does more compounding work.

Every legendary blowup involved someone excellent at X deciding they were probably also excellent at Y. Competence doesn't cross-collateralize.

O(1) hash lookup, O(log n) binary search, O(n log n) sort, O(n²) nested loops. The rule on a trading system: anything touching the hot path (tick processing, signal eval) must be O(1) or O(log n); O(n) scans belong in batch jobs.

Big-O hides constants: a cache-friendly O(n) array scan routinely beats a pointer-chasing O(log n) tree in real hardware. Measure, don't recite.

The workhorse: O(1) average lookup/insert. In market data: symbol → order book, order id → order state. Python dict, JS object/Map — most business logic is hash map choreography.

Worst case O(n) on collision floods; and iteration order assumptions differ by language — Python dicts preserve insertion order, others don't. Never rely on it across systems.

O(log n) insert/extract-min. Canonical in matching engines (best bid/ask), event schedulers in backtesters, top-K queries. Python heapq, or two heaps for a live order book.

A heap gives you the top, not sorted order — repeatedly popping to 'sort' is O(n log n) and destroys the structure. Wrong tool for range queries; that's a balanced tree's job.

Break a problem into overlapping subproblems, cache the answers. In finance: optimal execution (Almgren-Chriss discretized), American option exercise (backward induction on trees), Kelly with constraints.

DP's trap is state-space explosion — three state variables and your table no longer fits in memory. The art is finding the minimal sufficient state, not writing the recursion.

BFS/DFS for reachability, Dijkstra for shortest paths, topological sort for dependency ordering. In practice: currency arbitrage = negative cycle detection (Bellman-Ford on log prices), settlement chains, dependency graphs in build systems.

Triangular arbitrage via Bellman-Ford is the classic interview answer and a production trap: by the time you detect the cycle, it's gone. The algorithm is right; the latency assumption is fiction.

You almost never write a sort — you choose one: Timsort (Python/Java default) exploits pre-sorted runs, radix beats comparison sorts on fixed-width keys (timestamps!). Sorting a day of ticks by exchange timestamp: radix wins big.

Sorting inside a loop is the most common accidental O(n² log n) in quant code. Sort once, index forever.

Two schools: vectorized (pandas/numpy, fast, fine for signals on bars) vs event-driven (tick-by-tick simulation, order lifecycle, realistic fills). Rule: research in vectorized, validate in event-driven before capital.

Vectorized backtests silently peek: same-bar entry+exit, fills at close prices you couldn't have known. The gap between the two architectures IS your lookahead bias, quantified.

The two backtest killers: using information not yet available (revised data, close prices intraday), and testing on today's index constituents (companies that died are gone from the sample). Point-in-time databases exist precisely for this.

The most dangerous lookahead is subtle: normalizing by a full-sample mean, tuning on the whole set then 'validating' on part of it. If Sharpe > 3 in backtest, hunt for the leak before celebrating.

Exchange time vs receive time vs process time — three clocks, three stories. Always store UTC + exchange timezone separately; DST transitions have corrupted more P&L attributions than any bug class. Nanosecond precision matters at HFT, milliseconds for everyone else.

Joining two data sources on timestamp without specifying WHICH timestamp is a silent alignment error — your 'signal' may be the data vendor's clock skew.

L1 = best bid/ask, L2 = depth by level, L3 = individual orders. Storage explodes at L2+: a liquid future does millions of updates/day. Snapshot + incremental deltas is the standard; rebuild logic must handle gaps and crossed books.

Backtesting market-making on L1 data is fantasy — queue position, the thing that decides your fills, is invisible above L3. Know what your data can and cannot answer.

Raw → validated → adjusted → research-ready, each stage immutable and versioned. Corporate actions (splits, dividends) adjust historically; a price series without adjustment metadata is a lie waiting for a join.

Silent forward-fill is the pipeline's carbon monoxide: missing data becomes stale data becomes a mean-reversion signal that trades gaps in your vendor's coverage.

A trading process dies mid-session: what does restart look like? Event-sourcing (replay the log) or checkpoint+journal. Positions must reconcile against the broker, not against your own memory of what you sent.

The bug is never in the happy path. Systems fail at reconnect, partial fill during restart, duplicate order on retry — design the crash first, the strategy second.

Vectorize or die: .apply() with a Python lambda is a for-loop in a trench coat. groupby-transform for cross-sectional ops, merge_asof for point-in-time joins (THE quant join), categoricals for symbol columns — 10x memory savings.

Chained indexing (df[a][b] = x) silently writes to a copy — the SettingWithCopyWarning everyone ignores is telling you your backtest may be reading unmodified data.

Think in arrays: rolling windows via stride tricks or numba, broadcasting instead of loops, einsum for anything tensor-shaped. A 1000x speedup from removing one Python loop is normal, not exceptional.

Premature vectorization of unreadable one-liners costs more in debugging than it saves in runtime. Vectorize the hot loop the profiler found, not the code you suspect.

asyncio for I/O-bound (websocket feeds, REST polling), multiprocessing for CPU-bound (parallel backtests), threads mostly for legacy blocking libs. The GIL means Python threads don't parallelize computation — a fact rediscovered weekly.

Async code that touches shared state without locks works perfectly in testing and corrupts positions in production. Message-passing (queues) over shared memory, always.

Type hints + mypy catch the None-slips-through bug class before runtime. Property-based testing (hypothesis) finds edge cases you didn't imagine: negative prices, empty frames, DST days. A pricing function without tests is an opinion.

100% coverage of the wrong assertions is theater. Test the invariants that matter: P&L conservation, position reconciliation, no-arbitrage bounds on your own outputs.

The boring sequence wins: build → test → deploy → verify → (rollback path ready). PM2 for Node process management, nginx as reverse proxy, systemd for daemons. Never edit in production; the server is a cattle, not a pet.

The deploy that skips `npm run build` ships yesterday's code with today's confidence. If the sequence isn't a script, it isn't a sequence — it's a mood.

Structured logs (JSON), correlation ids across services, log levels that mean something. For trading: every order event logged with full context BEFORE the action — the log is your flight recorder when the exchange disputes a fill.

Logging inside the hot loop at DEBUG level is a latency tax you pay forever. And logs without timestamps in UTC are puzzles, not records.

API keys in environment variables or a vault, never in code, never in git history (git filter-repo exists because everyone learns this late). Separate keys per environment; trading keys get IP whitelists and withdrawal locks.

The leaked key isn't the one you committed — it's the one in the .env you copied to a backup, the notebook output, the error trace sent to a logging SaaS.

Timeouts on every external call, exponential backoff with jitter, circuit breakers, idempotency keys on order submission. The network WILL partition mid-order; 'exactly once' is a lie — design for 'at least once + dedupe'.

Retry without idempotency is how one order becomes five. The double-fill from an aggressive retry loop has bankrupted more small shops than bad strategies have.

Financial data: low signal-to-noise, non-stationary, one history. Any sufficiently flexible model WILL memorize noise. Defenses: fewer parameters than you want, regularization, and skepticism proportional to backtest beauty.

The model with 12 features and Sharpe 4 in-sample is not a discovery — it's a fitting exercise. De Prado's estimate: most published factor findings are false.

Standard K-fold leaks: overlapping samples share information across the train/test boundary. Purged K-fold (drop samples near the boundary) + embargo periods. Walk-forward is the honest default: train on past, test on strictly-after.

Shuffled CV on time series is lookahead with extra steps — the most common fatal flaw in ML-for-trading papers and Kaggle-trained hires.

Any feature computed with future information: full-sample z-scores, labels leaking into features via joins, target encoding fit on the whole set. The tell: performance too good, live results at random.

Leakage hides in preprocessing more than in features — the scaler fit on train+test is invisible in the code diff and fatal in production.

The market that generated your training data no longer exists. Retraining schedules, regime detection (HMM, change-point), and ensembles weighted by recency are mitigations — not solutions. There is no solution.

A model's silent decay looks exactly like bad luck for months. Log prediction-vs-realized continuously; the divergence chart is your model's vital signs.

Q·K similarity decides where information flows; V carries the content. Self-attention lets every token read every other token in one step — the O(n²) matrix that replaced recurrence and made parallel training possible.

O(n²) in sequence length is the architecture's tax: context windows are expensive by construction. Every 'infinite context' claim is an approximation (sparse, linear, sliding) trading exactness for reach.

Attention + FFN + residual connections + layer norm, stacked. Decoder-only (GPT lineage) won the generative war: next-token prediction on internet-scale text turns out to be a general-purpose learning objective.

The architecture is 2017-vintage and nearly unchanged — the gains since are data, scale, and post-training. Attributing capability jumps to architectural magic misreads where the leverage actually is.

Loss falls as a power law in parameters, data, and compute (Kaplan, then Chinchilla: most models were undertrained, not undersized). Compute-optimal ratios reshaped the field: data became the binding constraint.

Power laws in loss ≠ power laws in capability — downstream abilities emerge in jumps the loss curve doesn't show. Extrapolating the curve tells you the loss, not what the model can do.

BPE/SentencePiece chop text into subword units. The model never sees characters — it sees token ids. Why LLMs miscount letters, why Chinese costs more tokens per word, why 'strawberry' has three r's is hard.

Tokenizer choices are frozen at pretraining and haunt everything downstream: arithmetic, rhyming, code indentation. Many 'reasoning failures' are tokenization artifacts wearing a costume.

Autoregressive generation recomputes nothing: keys/values of past tokens are cached. Memory scales with context × layers — the real constraint on serving long contexts. Speculative decoding, batching, quantization are the serving trinity.

Latency-per-token and throughput trade against each other in batch serving; the demo is fast because it's alone. Production inference economics, not model quality, decide what ships.

Next-token prediction over trillions of tokens. The loss is simple; the engineering is not: data curation and dedup matter more than architecture tweaks. The base model is a simulator of its corpus, nothing more and nothing less.

Data contamination silently inflates every benchmark — the model has often seen the test. Treat leaderboard deltas under a few points as measurement noise.

Reward model from human preferences, then policy optimization (PPO) against it — or skip the RL and optimize preferences directly (DPO). This is what turned base-model autocomplete into an assistant.

Optimizing a learned reward invites reward hacking: the policy exploits the reward model's blind spots. Sycophancy is not a bug of alignment — it's the reward model's preference, faithfully maximized.

Agent, environment, reward: policy gradient (REINFORCE, PPO) learns behavior from delayed feedback; Q-learning learns state-action values. Deep RL cracked Go and Atari; in markets it meets non-stationarity and mostly loses.

Reward design IS the problem: agents optimize the metric, not the intent. Sparse rewards don't train; dense rewards get hacked. RL for trading founders on a regime-shifting environment with one non-repeatable history.

Full fine-tuning updates everything; LoRA freezes weights and trains low-rank adapters — 100x fewer trainable parameters, mergeable, stackable. The default for domain adaptation on a budget.

Fine-tuning teaches style and format far better than it teaches facts — knowledge injection via fine-tuning is unreliable; that's what retrieval is for. Catastrophic forgetting taxes every gradient step.

Student model trained on teacher outputs (logits or generations). How capability compresses downmarket: frontier-model behavior at a fraction of the inference cost. The moat question of the decade — see the distillation-moat thesis.

The student inherits the teacher's blind spots plus its own compression artifacts. Distilling from distillations compounds drift — the photocopier-of-a-photocopier problem at model scale.

Retrieve relevant chunks, stuff them in context, generate grounded answers. Embedding search + reranking + chunking strategy. The standard fix for knowledge freshness and hallucination on private corpora.

RAG quality is retrieval quality: bad chunking or embedding mismatch and the model confidently synthesizes from irrelevant context. Most 'hallucinations' in RAG systems are retrieval failures upstream.

LLM in a loop: plan, call tools, observe, iterate. Function calling, code execution, browsing. Reliability compounds inversely: a 95%-per-step agent fails 40% of 10-step tasks — the multiplication problem is the field's wall.

Agent demos cherry-pick the happy path. Production agents need verification layers, checkpoints, and human gates precisely because errors compound — architecture for failure, not for the demo.

The discipline above prompting: what enters the window, in what order, with what structure — system prompts, memory compression, pointer-based storage, kernel files. Managing the model's working memory as an engineered resource.

Context is not free attention: models attend unevenly (lost-in-the-middle), and stale context poisons more than it informs. Curation beats accumulation — the art is what you leave out.

You cannot improve what you cannot measure: golden sets, LLM-as-judge, regression suites on real failure cases. The eval set is the actual spec of your system — everything else is vibes.

LLM-as-judge inherits judge biases (verbosity, position, self-preference). And public benchmarks are marketing surfaces — internal evals on your own distribution are the only ones that predict your production.

The model outputs fluent falsehoods because it models plausibility, not truth. Mitigations: retrieval grounding, verification layers, uncertainty prompting, structured citation. Elimination is not on the menu; management is.

Confidence and correctness are uncorrelated at the output layer — the fluency that makes LLMs useful is the same property that makes their errors persuasive. Verification-first architecture is the honest response.

Chain rule applied through the computation graph: gradients flow backward, weights update. One algorithm, unchanged since the 1980s, underneath everything from MNIST to GPT.

Vanishing/exploding gradients shaped a decade of architecture design (residuals, normalization, careful init). When training diverges, the answer is usually plumbing, not theory.

SGD → momentum → Adam/AdamW as default. Warmup + cosine decay is the standard schedule. Learning rate is the single most important hyperparameter — everything else is second-order.

Adam's defaults hide a weight-decay bug fixed by AdamW; copied training scripts propagate superstitions. Tune LR first, believe nothing else until it's swept.

Dropout, weight decay, data augmentation, early stopping — all ways to buy generalization by constraining fit. In deep learning, scale itself regularizes: big models generalize better than classical theory predicted (double descent).

Financial data inverts the deep-learning instinct: tiny effective sample sizes mean classical overfitting discipline applies with full force — see overfitting in the Code tab.

Meaning as geometry: words, sentences, images mapped to vectors where distance ≈ similarity. The substrate of retrieval, recommendation, clustering, and RAG. king − man + woman ≈ queen was the demo; vector databases are the industry.

Embeddings encode the training distribution's biases and blind spots; out-of-domain similarity is confidently wrong. Domain-specific fine-tuned embeddings routinely beat bigger general ones.

Chain-of-thought made thinking visible; o1-style models made it trainable — RL on reasoning traces, spending inference compute to buy accuracy. The scaling axis moved from pretraining to test time.

Longer thinking helps verifiable domains (math, code) most; open-ended judgment gains less. And visible reasoning is not faithful reasoning — the chain can be post-hoc theater over a different computation.

Sparse activation: route each token to a few expert FFNs among many. Decouples parameter count from inference cost — how frontier models got huge without proportional serving bills.

Routing is learned and imperfect; load balancing fights training instability. Parameter counts became marketing: a sparse trillion is not a dense trillion.

Vision, audio, text in one model: shared embedding spaces, cross-attention over image patches. The interface implication is larger than the benchmark one — screenshots, charts, and documents become native inputs.

Vision-language models read charts worse than they claim: axis misreads and numeric hallucination persist. For financial charts, extraction-then-reason beats direct visual QA.

Learn the environment's dynamics, plan inside the learned simulation (Dreamer lineage, video-generation-as-physics). The bet: prediction of consequences is the substrate of general agency.

Photorealistic video ≠ causal understanding — generated physics violates conservation laws pixel-beautifully. The gap between rendering and modeling is the field's open wound.

Pair neural generation with symbolic checking: code that must compile, proofs that must verify, claims that must ground to sources. The reliability path for high-stakes domains — generation proposes, verification disposes.

The verifier is only as good as its coverage; unverifiable domains (strategy, taste, markets) get no such safety net. Where verification is impossible, epistemic honesty is the only remaining layer — the ZMACRO premise.

The primitive under signatures, Merkle trees, commitments, and proof-of-work. Collision resistance is the strongest property and the first to fall — MD5 broke in 2004, SHA-1 in 2017 (SHAttered), both by collision, not preimage.

Length-extension attacks on Merkle-Damgård constructions (SHA-256) let an attacker compute H(m‖pad‖m′) knowing only H(m) — this is why HMAC exists and why naive H(secret‖message) MACs are broken. Sponge constructions (SHA-3) are immune.

Authentication without shared secrets. Schnorr's linearity enables signature aggregation and MuSig — the reason Taproot exists. Ed25519 is deterministic: no per-signature randomness to leak.

ECDSA nonce reuse leaks the private key algebraically — two signatures with the same k solve for d in one line. Sony's PS3 fell to exactly this in 2010. RFC 6979 deterministic nonces are the fix, and are still not universally adopted.

Passwords must be slow to guess. Memory-hardness defeats GPU/ASIC parallelism — the entire point of Argon2id winning the Password Hashing Competition.

PBKDF2 with a low iteration count is a rounding error to a GPU farm. And a KDF protects at rest; it does nothing against phishing, credential stuffing from other breaches, or a compromised process reading plaintext in memory.

Forward secrecy means yesterday's traffic stays private even if today's long-term key leaks. ECDHE gives it; static RSA never did — which is why TLS 1.3 deleted it.

0-RTT data is replayable by design. Anything sent in 0-RTT must be idempotent — a fact routinely ignored, turning a latency optimization into a replay attack surface.

The highest-leverage attack in modern software: one upstream compromise reaches every downstream consumer. SBOMs, reproducible builds, and pinned hashes are the structural defences.

Pinning versions is not pinning code — a tag can be moved. Pin by content hash. And xz proved that a patient adversary can spend two years becoming the trusted maintainer; no technical control detects earned trust being spent.

Constant-time implementations are mandatory for anything touching key material: no secret-dependent branches, no secret-dependent memory indices. `crypto_verify` exists for this reason.

A `==` comparison on an HMAC leaks the correct prefix length through timing. Every hand-rolled auth check that returns early on first mismatch is a side channel. Spectre showed the CPU itself is the attack surface.

Most breaches are authorization failures, not cryptographic ones. IDOR (insecure direct object reference) is #1 on the OWASP API list: the token is valid, the object isn't yours.

Using OAuth access tokens as identity proof is the classic confused-deputy error — a token proves delegation, not who the bearer is. Every 'Login with X' built on bare OAuth 2.0 has this bug.

Replaces the castle-and-moat model that fails the moment one internal host is compromised. Microsegmentation limits lateral movement — the difference between an incident and a breach.

Zero trust is an architecture, not a product, and it is sold as a product. Bolting an identity proxy in front of a flat internal network buys a login page, not segmentation.

The defining unsolved problem of LLM agents. Mitigations: privilege separation (the model never holds the capability), dual-LLM patterns, output filtering, human confirmation on side-effectful actions.

It is not patchable by better prompting. 'Ignore previous instructions' filters are trivially bypassed by encoding, translation, or indirection. Treat every model output derived from untrusted input as untrusted — the same discipline as SQL injection, before parameterized queries existed.

Web-scraped pretraining data is attacker-writable by construction. Expired domains in curated datasets can be re-registered and repopulated — a documented, cheap attack.

Backdoors survive fine-tuning and are near-undetectable by benchmark evaluation, because the trigger is off-distribution by design. You cannot test for a behaviour whose activation condition you don't know.

The model is the asset; the API is a leak. Rate limiting, output perturbation, and watermarking are partial defences. Differential privacy bounds membership inference at a measurable utility cost.

Distillation from a frontier API is model extraction with a business plan. And DP-SGD's ε values used in practice (ε≈8) provide far weaker guarantees than the formalism suggests to non-specialists.

The right frame: the model is an untrusted planner, and the tool layer is the security boundary. Capabilities must be scoped per-task, not per-session. Irreversible actions require out-of-band confirmation.

Reliability compounds against you: a 95%-per-step agent fails ~40% of 10-step tasks, and a security failure need only happen once. Demos hide this; production doesn't.

Cryptography reduces the problem of protecting data to the problem of protecting keys — and then most systems fail at the second half. The key's lifecycle is the actual security boundary.

A key in an environment variable is a key in every crash dump, every `ps` output, every logging SaaS. And rotation without revocation is theatre: the old key still decrypts the old ciphertext.

Assume breach. The question is not whether an adversary gets in but how long they operate unobserved. Canary tokens, honeypots, and behavioural baselines beat signature matching against a motivated attacker.

Alert fatigue is an availability attack on your analysts. A detection rule that fires a thousand times a day trains the team to ignore the one time it matters.

Security is a property of a system in a context, not a checklist. The exercise forces you to name the adversary — a nation-state, a script kiddie, and a disgruntled insider demand different architectures.

'Our threat model is everyone' means you have no threat model. Without a named adversary with named capabilities and named goals, every control is equally justified and none is prioritised.

Nakamoto consensus: the longest chain is the one with most accumulated work. Finality is probabilistic — 6 confirmations is a convention, not a theorem. Settlement assurance grows with depth and with the cost of reorganisation.

51% is not a threshold, it is a price. Selfish mining is profitable below 50% (Eyal-Sirer). And 'energy waste' misframes it: the energy IS the security, denominated in dollars per reorg.

Security budget decouples from energy and attaches to the staked asset. Slashing makes equivocation cost capital rather than merely forgoing reward — this is what fixes nothing-at-stake.

Long-range attacks require weak subjectivity: a new node must trust a recent checkpoint from outside the protocol. PoS finality is economic, not physical — an attacker who can acquire and burn ⅓ of stake can halt the chain.

The number that matters for anyone settling value. Exchanges' confirmation policies are a direct pricing of reorg risk against withdrawal latency.

CAP applies: you cannot have finality and liveness under partition. BFT chains halt; Nakamoto chains fork and heal. Which failure you prefer is a business decision disguised as a technical one.

MEV is not a bug: it is the on-chain analogue of order-flow payment and front-running, made explicit and auctioned. Flashbots turned a latency race into a sealed-bid auction, reducing chain congestion.

MEV centralises: builders with better order flow win, and the builder market concentrates. Censorship resistance degrades when a handful of builders construct most blocks — a documented, measurable trend.

A passive market maker with no order book. Uniswap v3's concentrated liquidity turns an LP position into a portfolio of range orders — mathematically, a short-gamma payoff around the range.

'Impermanent' is marketing. It is permanent the moment you withdraw at a different price, and it is precisely the premium an LP sells: LPs are short volatility, paid in fees. Fee income must exceed realised variance × exposure, or the position loses.

The dominant crypto derivative by volume. Funding is a directly observable, tradeable carry — the market's price of leverage, and one of the cleanest sentiment gauges that exists.

Funding is not arbitrage-free carry: it is a mechanism, not a no-arbitrage condition. It can persist far from theoretical carry for weeks. And cascading liquidations mean the peg holds until it violently doesn't.

Composability: an option token is an ERC-20 that other protocols can accept as collateral. This is the genuine structural advantage over CeFi — not price, not fees.

Every margined on-chain option is a bet on an oracle. Options liquidity is thin, and the vol surface it implies is a liquidity artefact more than a forecast. Compare with the CeFi surface before trusting it.

The bridge between the deterministic machine and the world. Every collateralised protocol's solvency reduces to its oracle's correctness and latency.

The oracle problem is unsolved and often the entire attack surface: Mango Markets ($114M, 2022) was an oracle manipulation, not a code bug. TWAP resists manipulation by being slow — and a slow oracle is a free option for the liquidator's counterparty.

Verification is exponentially cheaper than computation — the entire basis of ZK rollups. Also enables private state: prove solvency without revealing the balance sheet.

'Zero knowledge' in rollups is a misnomer: they use succinctness, not privacy. And a trusted setup is a trusted setup — the toxic waste must actually be destroyed, and you cannot verify that it was.

The scaling answer that keeps security: the L1 is the court, the L2 is the venue. EIP-4844 blobs cut data cost by an order of magnitude and reshaped L2 economics overnight.

Almost every rollup still has an upgrade multisig — a trusted third party wearing a trustless costume. Read L2Beat's stage classification before believing a security claim.

The unglamorous constraint that determines whether a rollup is a rollup or a database with a Merkle root. Celestia, EigenDA, and blobs are all answers to this one question.

'Validium' means the DA is off-chain, which means the operator can freeze your funds by withholding data. It is a different trust model, marketed as a cheaper rollup.

Code is law, including the bugs. The DAO (2016, reentrancy) forced a hard fork and created ETC. Formal verification, invariant testing (Echidna, Foundry fuzzing), and staged rollouts with caps are the mature defences.

An audit is a point-in-time opinion, not a guarantee, and most exploited protocols were audited. Economic exploits (not code bugs) dominate losses now — the code does exactly what it says, and what it says is exploitable.

A bridge is a bank whose vault is a multisig. The security of a wrapped asset is the security of the weakest bridge that can mint it, not of the chain it sits on.

Cross-chain composability multiplies attack surface: an asset bridged twice inherits both bridges' trust assumptions. Vitalik's argument against cross-chain applications is a security argument, not a tribal one.

A token is a claim on a cash flow, a governance right, or a Schelling point — and the design must say which. ve-models trade liquidity for alignment; they concentrate power in whoever locks longest.

If the cost to buy quorum is less than the treasury, the treasury is a bounty. Beanstalk lost $182M to a flash-loan governance attack executed in a single block — the vote was entirely legitimate.

The binding constraint on any on-chain business, and the one most protocol teams model last. Where a product touches fiat, a licensed counterparty is not optional.

'Sufficiently decentralised' is a regulatory hope, not a legal test — no statute defines it. Building on the assumption that decentralisation grants immunity has ended in enforcement, repeatedly.