Black-Litterman model

Hand an unconstrained mean-variance optimizer a vector of expected returns and it will find you the mathematically optimal portfolio for exactly those numbers, which is the problem, because AA1.01 already showed that ordinary estimation noise in that vector routes straight through to wild, unstable weights. Black-Litterman's insight (Black & Litterman, 1992, building on earlier equilibrium work) is to stop asking "what do I, alone, believe the expected returns are?" and start with a better-anchored question: "what expected returns are already implied by the market portfolio everyone actually holds?" That anchor is called the equilibrium return, and nothing about it is guessed. It is reverse-engineered from observable market-cap weights via the exact same logic CAPM already uses forward (M3.02 §4.6): if the market clears at these weights, these must be the returns the market is collectively demanding. You then adjust that anchor only where you hold a genuine view, sized to your actual confidence, never replacing the whole return vector with your own numbers from scratch. The result is a return vector that behaves itself: small, disciplined, and traceable to two named sources (the market's own pricing, and your stated view) rather than to whatever a five-year trailing average happened to produce.

Reverse optimization: equilibrium returns from market weights

Markowitz's investor maximizes E[Rp] − (δ/2)σp², expected return net of a risk penalty, where δ ("delta") is the risk-aversion coefficient: how many units of expected return the investor demands per unit of variance. For a portfolio of weights w and covariance matrix Σ, the first-order condition of that maximization is:

Π = δ · Σ · w

Π ("Pi") is the vector of equilibrium excess returns (over the risk-free rate) implied by holding weights w. δ itself has a clean interpretation and a clean formula: it is the market's own Sharpe-like ratio rescaled (δ = (E[Rm] − Rf) / Var(Rm)) the equity risk premium divided by the market's own variance. Typical planning values for an equity-anchored benchmark run δ ≈ 2.5–3.5; this module uses δ = 3.0 throughout.

Work it by hand on a 60/40 Equity/Bond benchmark. Take equity volatility σ = 20%, bond volatility σ = 6%, correlation ρ = 0.10 (both figures sit inside the expected return formula page's 15–25% broad-index band; the pair is illustrative, not a live quote). In decimal-return units:

Σ = [ 0.0400   0.0012 ]      w = [0.60, 0.40]
    [ 0.0012   0.0036 ]

Σw: row 1 = 0.0400×0.60 + 0.0012×0.40 = 0.02448; row 2 = 0.0012×0.60 + 0.0036×0.40 = 0.00216. With δ = 3.0:

Π = 3.0 × [0.02448, 0.00216] = [0.07344, 0.00648]  →  Π = [7.34%, 0.65%]

Read this as: given the market holds 60% equity and 40% bonds at these volatilities and this correlation, it must be collectively demanding a 7.34% excess return on equity and a 0.65% excess return on bonds, a 6.70-point equilibrium spread. Verify one identity before you trust any of this further, because it is the single fastest way to catch a broken build: feed Π straight back through the same optimizer with zero views, and you must get back exactly the weights you started with. Formally, Σ⁻¹Π = δw, always, by construction, because Π was defined as δΣw in the first place. The module's script confirms it to machine precision every time; if your own build does not reproduce this identity, the bug is in your Σ or your δ, not in Black-Litterman.

Blending in a view: the posterior, derived by hand

A view is a statement of the form "portfolio P will earn Q", most often a relative view ("equity will beat bonds by some margin"). You express it as a row vector P (the weights of the "view portfolio": +1 on the asset you favor, −1 on the asset you're stating it against, 0 elsewhere) and a scalar Q (your stated expected excess return for that view-portfolio). You also need Ω ("omega"), the view's own uncertainty: how confident you are. This module uses the common convention Ω = τ·(PΣP′): your view's variance scales with the view-portfolio's own variance under Σ, times a small scalar τ ("tau," typically 0.01–0.05; this module uses τ = 0.05) that represents how much uncertainty attaches to the equilibrium estimate itself (as distinct from Σ, which describes uncertainty in actual period-to-period returns). A smaller τ means you trust Π tightly and a view needs more conviction (a smaller Ω) to move it much; a larger τ loosens that trust.

Black-Litterman formula

The full multi-view Black-Litterman formula is a matrix expression (E[R] = [(τΣ)⁻¹ + P′Ω⁻¹P]⁻¹[(τΣ)⁻¹Π + P′Ω⁻¹Q]) genuinely needed once you hold two or more simultaneous views, and it is what a solver runs (see the section on going beyond one view). But for exactly one view (the case you will meet most often, and the one to own cold) the Ω = τ(PΣP′) convention collapses the whole expression to a hand-computable closed form:

E[R] = Π + ½ × [ΣP′ / (PΣP′)] × (Q − PΠ)

Read every piece of this before you plug in numbers, because each has a plain-English meaning. The term PΠ is the equilibrium's own implied value for your view-portfolio: the 6.70-point spread just computed, for instance. Then Q − PΠ is the surprise: how far your stated view differs from what the market already prices in, not from zero. And ΣP′ is a vector of each asset's covariance with the view-portfolio, while PΣP′ is the view-portfolio's own variance. The ratio ΣP′/(PΣP′) is a vector of regression-like "betas" of every asset onto the view, and it is this vector, scaled by the surprise, that gets added to Π. The ½ factor is specific to the Ω = τPΣP′ convention (a different Ω convention replaces it with a different, still-simple scalar).

Worked example: a view that equity beats bonds by 10 points

Compute it, same 60/40 pair, a stated view that equity beats bonds by 10 points (P = [1, −1], Q = 0.10):

PΣ  = [1,−1]·Σ = [0.0400−0.0012, 0.0012−0.0036] = [0.0388, −0.0024]
PΣP′ = 0.0388×1 + (−0.0024)×(−1) = 0.0412
PΠ   = 7.34% − 0.65% = 6.70%  (the equilibrium spread already computed)
Q − PΠ = 10% − 6.70% = 3.30 points  (the surprise: MORE bullish than consensus)

tilt = 0.5 × [0.0388, −0.0024] / 0.0412 × 0.0330 = [+1.56pp, −0.10pp]
E[R] = Π + tilt = [7.34+1.56, 0.65−0.10] = [8.90%, 0.55%]

Equity's posterior return rises and bonds' falls, intuitive, because a 10-point spread view is more bullish on equity-over-bonds than the 6.70-point spread already priced in. Watch this reverse if the stated view is below the equilibrium spread. Re-run the identical formula with a "bullish-sounding" Q = 3% (equity will beat bonds by 3 points): the surprise is 3% − 6.70% = −3.70 points, negative, because the market's own equilibrium already implies more outperformance than your stated view, and the posterior comes out [5.60%, 0.76%]: equity's estimate falls, bonds' rises, even though the raw view sounded positive in isolation. Black-Litterman never asks "is this view bullish?" in a vacuum; it asks "is this view more or less bullish than what's already priced in?", a view stated without checking it against PΠ first is the most common way analysts mis-read their own model's output (Common mistakes, item 1).

Beyond one view: the general case, and where the software takes over

Everything in the posterior derivation generalizes cleanly the moment you hold two or more simultaneous views, say, "equity beats bonds by 8 points" and, independently, "gold beats bonds by 2 points." Then P becomes a 2×N matrix (one row per view), Q a 2×1 vector, and Ω becomes a 2×2 matrix (commonly diagonal, one uncertainty per view, assumed independent of each other unless you have a specific reason to model view-correlation). The closed form above no longer applies; you need the full matrix expression from the Black-Litterman formula and a genuine matrix inversion. This is exactly the boundary where a working allocator hands the mechanical algebra to code (the Modern Data Analysis callout) while still owning every input (Σ, δ, τ, and the views themselves) and every sanity check (the no-view identity of the reverse optimization; the "does the tilt direction make sense given Q vs PΠ" check from the posterior derivation).

Worked Example 1 runs the full three-asset build for a real allocation problem. It holds a single view, chosen deliberately so that the closed-form posterior applies and you can audit every step by hand. It then contrasts that build against feeding the same optimizer a set of noisy historical returns, reproducing AA1.01's instability finding side by side with Black-Litterman's discipline.

{
  "skill": "Standing up a Black-Litterman (or general multi-view) optimization scaffold quickly",
  "use": "Have an AI coding assistant draft the matrix-algebra scaffold — reverse optimization, the multi-view posterior blend, the matrix inversions — in Python, so your own time goes to the capital-market assumptions (Sigma, delta, tau) and the views themselves, not to debugging linear-algebra syntax.",
  "tools": ["Chat/coding assistants — Claude, ChatGPT, GitHub Copilot", "Notebook environments running numpy/scipy (G2/QD1.04 builds and hardens this exact stack)"],
  "prompt": "Write a Python function implementing Black-Litterman: given a covariance matrix Sigma, market-cap weights w_mkt, risk-aversion delta, a view matrix P, view vector Q, and tau (with Omega = tau * P @ Sigma @ P.T), return the equilibrium returns Pi and the posterior expected returns via the standard closed form. Include an assertion that zero views returns Pi unchanged and that Sigma^-1 @ Pi equals delta * w_mkt.",
  "verify": "Never trust the AI's matrix algebra unchecked — recompute the no-view identity (Sigma^-1 @ Pi == delta * w_mkt exactly, Guardrail #3 Recompute) and cross-check at least one posterior figure against this module's hand-derivable single-view formula before any output reaches a real memo. A silently transposed matrix or a mis-specified Omega still returns a plausible-looking number — this is AI0.01's 'plausible, not true' in its purest quantitative form. Run Guardrail 1-5 in full before a client sees the figure.",
  "diy": "You must already be able to compute Pi = delta*Sigma@w and the single-view posterior by hand for a 2-3 asset case (this module's Core Teaching) before delegating the N-asset, multi-view case to a tool — otherwise you cannot tell a correct scaffold from a subtly broken one.",
  "market": "US"
}