Why does combining two risky assets sometimes make them safer?

Risk as variance — what 'risky' actually measures

In finance, risk is shorthand for how much the outcome jitters around its average, not how much you might lose worst-case. The standard tool is variance : $Var(r) = E[(r − μ)²]$ — the expected squared deviation. Its square root, the standard deviation $σ$, has the same units as the return and is what most people mean by “volatility.” Doubling σ is “twice as risky” in this sense; halving it is “half as risky.” It’s an imperfect proxy (a chart that crashes once doesn’t have the same character as one that wobbles every day, even at matched σ), but it’s the coordinate that quadratic math lives in. Modern Portfolio Theory, capital asset pricing, Sharpe ratios — all sit on top of variance.

Two assets, four numbers

Pick two assets, A and B. Each has a mean return and a variance: $μ_A, σ_A², μ_B, σ_B²$. Mix them in proportion $w$ in A and $1−w$ in B. The mean of the mix is the easy part — averaging:

$μ_p = w μ_A + (1−w) μ_B$

If you only cared about means, mixing assets with the same μ is pointless: you get the same μ. But the variance of the mix has three terms, not two:

$σ_p² = w² σ_A² + (1−w)² σ_B² + 2 w (1−w) Cov(A, B)$

The first two are what you’d guess: each asset’s own variance, scaled by its share squared. The third — the covariance — is the surprise. It’s the cross-term, and it’s where mixing earns or loses you something. When A and B move together (positive covariance), mixing piles risk on. When they move opposite (negative covariance), mixing cancels risk.

import numpy as np

# Two assets: same mean return 5%, same standard deviation σ = 1.
# We'll compute portfolio mean and variance for any (weight, correlation).
mu_A, mu_B = 0.05, 0.05
sig_A, sig_B = 1.0, 1.0

def portfolio(w, rho):
    """w: fraction in A; (1-w) in B. rho: correlation of returns."""
    mu  = w * mu_A + (1 - w) * mu_B
    var = (w**2 * sig_A**2
         + (1 - w)**2 * sig_B**2
         + 2 * w * (1 - w) * rho * sig_A * sig_B)
    return mu, var

# Same expected return regardless of weight (because mu_A == mu_B).
# Variance is what moves.
[(rho, *portfolio(w=0.5, rho=rho)) for rho in (1.0, 0.0, -1.0)]
# → [(1.0,  0.05, 1.00),    perfect lockstep — no diversification benefit
#    (0.0,  0.05, 0.50),    independent — variance halves at 50/50
#    (-1.0, 0.05, 0.00)]    perfect anti — risk literally vanishes

Correlation — covariance, normalized

Covariance has awkward units (the product of A’s units and B’s units), so people quote the unit-free version: correlation $ρ = Cov(A, B) / (σ_A σ_B)$, which lives in $[−1, 1]$. Now the variance formula reads:

$σ_p² = w² σ_A² + (1−w)² σ_B² + 2 w (1−w) ρ σ_A σ_B$

Three regimes. $ρ = +1$ — perfect lockstep — and $σ_p$ is just the weighted average of $σ_A$ and $σ_B$. Mixing buys nothing. $ρ = 0$ — independent — and the cross-term vanishes; $σ_p²$ falls strictly below the weighted average of the variances. $ρ = −1$ — perfect anti-lockstep — and the cross-term is negative, large; with $σ_A = σ_B$ at $w = 1/2$ the variance hits exactly zero. Risk doesn’t just shrink; it disappears. The widget above is a one-line dial through these three regimes.

# Minimum-variance weight, closed form.
# Take d/dw of σ²_p(w) and set to zero:
#   w* = (σ_B² − ρ σ_A σ_B) / (σ_A² + σ_B² − 2 ρ σ_A σ_B)
def min_var_weight(rho, sig_A=1.0, sig_B=1.0):
    num = sig_B**2 - rho * sig_A * sig_B
    den = sig_A**2 + sig_B**2 - 2 * rho * sig_A * sig_B
    return num / den if abs(den) > 1e-12 else 0.5

[(rho, min_var_weight(rho)) for rho in (-1, -0.5, 0, 0.5, 0.99)]
# → [(-1,    0.50),    A and B equally weighted — perfect cancellation
#    (-0.5, 0.50),    still 50/50 because σ_A = σ_B
#    (0,    0.50),
#    (0.5,  0.50),
#    (0.99, 0.50)]
# With σ_A = σ_B the answer is always 0.5; differing σ's would tilt w*.

It's the same algebra as |a + b|² in vectors

The portfolio variance formula isn’t a finance invention — it’s the formula for the squared length of a vector sum, dressed in finance words. Treat returns as random vectors: each asset is one component of a 2D vector, and the portfolio is a weighted combination. The squared length identity from the vectors module:

$|a + b|² = |a|² + |b|² + 2 a · b$

Replace $|a|²$ with $w² σ_A²$, $|b|²$ with $(1−w)² σ_B²$, and the dot product $a · b$ with $w (1−w) Cov(A, B)$ — and you’ve recovered portfolio variance. Covariance is just a dot product on random variables. The cosine of the angle between them is correlation. “Two assets at right angles” means uncorrelated; “two assets pointing the same way” means correlated; “two assets pointing opposite” means anti-correlated, and that pair cancels.

This is why the vectors module is consumed by physics, graphics, ML, and finance: the same two operations (add and scale) that move a Bezier control handle also build a portfolio. The applications don’t share theorems — they share the algebra.

The minimum-variance mix

Set $d/dw [σ_p²] = 0$: a one-line calculus problem. The answer is

$w* = (σ_B² − ρ σ_A σ_B) / (σ_A² + σ_B² − 2 ρ σ_A σ_B)$

When $σ_A = σ_B$, this reduces to $w* = 1/2$ for any $ρ$: the safest mix of two equally-volatile assets is always half-and-half. When $σ_A ≠ σ_B$, the formula tilts: the lower-volatility asset gets more weight, but the tilt depends on $ρ$ too. The widget marks $w*$ as the green dot on the variance curve; drag $ρ$ and watch the curve flatten or sharpen around it. The full Modern Portfolio Theory generalization — N assets, an N×N covariance matrix, a quadratic to minimize subject to constraints — is just this same calculation written in vector-matrix form. One pair, three terms, one cross-term. Everything else is bookkeeping.

# Sanity check via Monte Carlo: simulate joint returns at given ρ,
# form the 50/50 portfolio, measure realized variance, compare to formula.
import numpy as np

def simulate(rho, n=200_000, seed=0):
    rng = np.random.default_rng(seed)
    z1 = rng.standard_normal(n)
    z2 = rng.standard_normal(n)
    a = mu_A + sig_A * z1
    b = mu_B + sig_B * (rho * z1 + np.sqrt(1 - rho**2) * z2)
    p = 0.5 * a + 0.5 * b
    return p.mean(), p.var()

formula = portfolio(w=0.5, rho=-0.5)
sim     = simulate(rho=-0.5)
formula, sim
# → ((0.05, 0.25), (0.0501, 0.2503))
# Closed form and simulation agree to three decimals.
# The whole MPT machinery from Markowitz onward sits on top of this single
# scalar identity; the rest is generalizing to N assets and adding
# constraints (no shorts, sector caps, etc.).