From Frontier to Weights

Portfolio theory gave you a gorgeous picture — an efficient frontier curving up and to the left, a tangency portfolio, a capital market line — and then waved its hands at the part that actually matters to a trader: which assets do I buy, and how much of each? That answer is a list of numbers called weights, and producing it from real data is the entire job of portfolio optimization. This lesson nails down the problem precisely: what you’re solving for, what you feed in, and what “optimal” even means once you stop drawing curves and start computing vectors. Everything in this course is an answer to one question — given my beliefs about the assets, what weights should I hold? — so let’s state that question with no hand-waving.

What a portfolio actually is: a vector of weights

Analogy. Think of your capital as a pie and each asset as a slice. The recipe for the pie is just the list of slice sizes: 40% stocks, 30% bonds, and so on. That list — one number per asset — is the portfolio. Change the numbers and you have a different portfolio; nothing else about it is fundamental.

Definition. A portfolio of $N$ assets is a vector of weights $w = (w_1, w_2, \dots, w_N),$ where $w_i$ is the fraction of total capital invested in asset $i$. The defining constraint is that the weights sum to one: $\sum_{i=1}^N w_i = 1.$ That budget constraint says you invest all your money and no more. A weight can be negative — that’s a short position, where you borrow and sell an asset, using the proceeds to buy more of something else (so the longs can sum to more than 100%). A long-only portfolio additionally requires every $w_i \ge 0$.

Worked example. You have $100,000. You put $60,000 in a stock fund, $30,000 in bonds, and $10,000 in gold. The weights are $w = \left(\tfrac{60\,000}{100\,000}, \tfrac{30\,000}{100\,000}, \tfrac{10\,000}{100\,000}\right) = (0.6,\ 0.3,\ 0.1),$ and indeed $0.6 + 0.3 + 0.1 = 1$. Now suppose instead you short $20,000 of gold and use the cash to buy $120,000 of stock: $w = (1.2,\ 0.0,\ -0.2)$, which still sums to one ($1.2 + 0 - 0.2 = 1$). Same budget, very different bet.

The two inputs: expected returns μ and covariance Σ

Every mean-variance optimizer eats exactly two things. Get these wrong and nothing downstream can save you — which is the running theme of this whole course.

Input 1 — expected returns (μ). A vector $\mu = (\mu_1, \dots, \mu_N)$ giving your forecast of each asset’s average future return. This is the reward side. Crucially, these are forecasts — guesses about the future — and they are the hardest thing in finance to estimate accurately.

Input 2 — the covariance matrix (Σ). An $N \times N$ table capturing risk and co-movement. Its diagonal entry $\Sigma_{ii} = \sigma_i^2$ is asset $i$‘s variance (volatility squared); its off-diagonal entry $\Sigma_{ij} = \sigma_i \sigma_j \rho_{ij}$ is the covariance between assets $i$ and $j$, where $\rho_{ij}$ is their correlation. This is the risk side, and it encodes the diversification that makes portfolios worth building in the first place.

From these two inputs, the portfolio’s expected return and variance are compact matrix expressions: $\mathbb{E}[r_p] = w^\top \mu, \qquad \mathrm{Var}(r_p) = w^\top \Sigma\, w.$

Worked example (two assets). Let $\mu = (8\%,\ 4\%)$, with volatilities $\sigma_1 = 20\%$, $\sigma_2 = 10\%$, and correlation $\rho = 0.3$. The covariance matrix is $\Sigma = \begin{pmatrix} 0.20^2 & 0.20\cdot 0.10\cdot 0.3 \\ 0.20\cdot 0.10\cdot 0.3 & 0.10^2 \end{pmatrix} = \begin{pmatrix} 0.04 & 0.006 \\ 0.006 & 0.01 \end{pmatrix}.$ For an equal-weight portfolio $w = (0.5, 0.5)$:

• Expected return: $w^\top \mu = 0.5(8\%) + 0.5(4\%) = 6\%$.
• Variance: $w^\top \Sigma w = 0.5^2(0.04) + 0.5^2(0.01) + 2(0.5)(0.5)(0.006) = 0.01 + 0.0025 + 0.003 = 0.0155$.
• Volatility: $\sqrt{0.0155} \approx 12.45\%$.

Notice the volatility (12.45%) is below the simple average of the two asset vols ($\tfrac{20\% + 10\%}{2} = 15\%$). That gap is diversification, and it lives entirely in the off-diagonal covariance term. If the assets were perfectly correlated ($\rho = 1$), that term would be bigger and the gap would vanish.

The optimization problem, stated plainly

Now we can write down what we’re actually solving. Mean-variance optimization comes in a few equivalent flavors, but they all trade off the same two quantities: reward ($w^\top\mu$) and risk ($w^\top\Sigma w$).

Flavor 1 — minimize risk for a target return. Pick the lowest-variance portfolio that achieves a required expected return $r^*$: $\min_w\ w^\top \Sigma\, w \quad \text{s.t.}\quad w^\top \mu = r^*,\ \ \mathbf{1}^\top w = 1.$

Flavor 2 — maximize the risk–reward trade-off. Maximize a utility that rewards return and penalizes variance, where $\lambda$ is your risk aversion: $\max_w\ w^\top \mu - \tfrac{\lambda}{2}\, w^\top \Sigma\, w \quad \text{s.t.}\quad \mathbf{1}^\top w = 1.$

Flavor 3 — maximize the Sharpe ratio. Find the portfolio with the best return per unit of risk (the tangency portfolio): $\max_w\ \frac{w^\top \mu - r_f}{\sqrt{w^\top \Sigma\, w}}.$

As you sweep the target return $r^*$ (or the risk aversion $\lambda$) across all values, the solutions trace out the efficient frontier you already know. So “solving for the weights” means: fix what you want (a target, a risk aversion, or the best Sharpe), then find the weight vector that achieves it with no waste.

What “solving” looks like — and why it’s not just plug-and-play

For the simplest case (no short-sale or box constraints, just the budget constraint), the optimizer has a closed-form solution: a tidy formula involving the inverse of the covariance matrix, $\Sigma^{-1}$. You’ll meet it in detail in lesson 3. The key structural fact — and the seed of every problem to come — is that the answer depends on inverting Σ.

Why that matters. Inverting a matrix is exquisitely sensitive to errors when the matrix is ill-conditioned — when some assets are nearly redundant (highly correlated). A near-singular Σ has an inverse with gigantic entries, and those gigantic entries multiply your estimation errors into gigantic, unstable weights. This is the mechanical reason the naive optimizer behaves so badly, and it’s why the back half of this course is devoted to taming Σ (with shrinkage) and constraining $w$ (with bounds and penalties).

When constraints enter, the closed form usually disappears and you solve numerically with a quadratic program — a standard, fast, reliable optimization routine that handles “weights sum to 1”, “no shorts”, “no more than 5% in any one name”, “turnover below 20%”, and so on, all at once. Real desks almost always run the constrained, numerical version, never the raw closed form.

Putting it together

A portfolio is a vector of weights $w$ summing to one — negative weights are shorts, all-nonnegative is long-only — and that vector is the concrete thing you trade. A mean-variance optimizer takes two inputs: expected returns $\mu$ (reward) and the covariance matrix $\Sigma$ (risk and co-movement), from which $\mathbb{E}[r_p] = w^\top\mu$ and $\mathrm{Var}(r_p) = w^\top\Sigma w$. Solving for the weights means minimizing risk for a target return, maximizing a return-minus-risk utility, or maximizing the Sharpe ratio — and sweeping the target traces the efficient frontier. The clean unconstrained solution depends on $\Sigma^{-1}$, which is exactly why a near-singular, error-laden $\Sigma$ makes the naive optimizer fragile — the headline problem this course will diagnose and then fix with constraints and shrinkage.

Next up — the covariance matrix itself: how it’s built, why it must be positive semidefinite, how its sheer size explodes with the number of assets, and what “ill-conditioned” really means. Σ is the beating heart of every risk calculation in this course, and understanding its structure is the prerequisite for understanding why optimization is so fragile — and how to fix it.