As the trade-off between expected return and variance changes, the optimal portfolio moves along straight lines and changes direction only at finitely many corner portfolios, where an asset enters or leaves. Markowitz’s Critical Line Algorithm (CLA) (Markowitz, 1956) walks from one corner to the next. The LASSO (Tibshirani, 1996) behaves the same way as its penalty moves, and the LARS algorithm (Efron et al., 2004) walks its corners, which statisticians call knots. Schmelzer and Hastie (2026) prove that after a change of variables the two paths coincide. This note checks that result numerically, by computing frontiers with a LASSO solver and testing them against independent solvers, in three settings:

The usual alternative is to solve a quadratic program on a grid of tilts. Each solve is only as accurate as its tolerance, and every corner between two grid points is missed. A path algorithm returns the corners themselves, and every other frontier portfolio is a linear interpolation between two of them.

Markowitz (1952) called a portfolio efficient if no other has a higher expected return E without a higher variance V, or a lower V without a lower E. Traced by minimising 12V−λE over fully invested portfolios for λ≥0, they form the efficient frontier, with the minimum-variance portfolio at λ=0. The CLA followed (Markowitz, 1956). Tobin (1958) and Sharpe (1964) moved the picture to the (σ,E) plane, where Sharpe located the dominant portfolio, the one with the highest Sharpe ratio, at the tangent from the riskless rate.

The LASSO fits least squares under ‖β‖1≤t and so shrinks and selects at once. Its path is piecewise linear in t. Osborne, Presnell and Turlach (2000) gave a homotopy for it and Efron et al. (2004) gave LARS, which also covers the positive LASSO. Later practice moved to coordinate descent on a grid of penalties (Friedman et al., 2010), which, like a grid of tilts, returns points rather than corners.

The two literatures developed for decades without citing each other (Schmelzer & Hastie, 2026, Section 5). The best-known bridge, Brodie et al. (2009), read a Markowitz problem with a gross-exposure penalty as a LASSO, but swept the penalty at a fixed target return rather than tracing the frontier. Fan, Zhang and Yu (2012) ran LARS along the gross-exposure cap of the minimum-variance portfolio. They removed the budget by regressing on a reference asset, which leaves an ℓ1 constraint that is no longer the LASSO’s, so their path is an approximation.

The test problem is the seeded 20-asset example of Figure 1 in Schmelzer & Hastie (2026): a five-factor covariance Σ=diag⁡(d)+Udiag⁡(δ)U⊤, and μ the sample mean of 50 days of returns simulated from it. Its units are arbitrary and its expected returns large against its risk, so Sharpe ratios reach 2.1 per period, far above anything real assets offer. It is for illustration only; Section 8 adds real portfolio returns and a larger universe on a daily scale. The companion script python/make_figures.py regenerates every figure and number in the note, and its tests check each against a tolerance. The statement on code and data availability at the end says where to find it.

Let Σ≻0 be the covariance of n assets and μ their expected returns. With the Cholesky factor Σ=LL⊤, set X=L⊤ and y=L−1μ, so that X⊤X=Σ and X⊤y=μ. Then for every portfolio w 12w⊤Σw−μ⊤w=12‖y−Xw‖22−12‖y‖22,(1) and under any constraints the mean–variance problem is a least-squares problem.

The last line solves the normal equations X⊤Xw=X⊤y, which are Σw=μ. With constraints, the optimality conditions become normal equations restricted to the assets held, a linear system in the trade-off parameter. The weights stay linear until the holdings change, and those changes are the corners. The substitution is a change of variables, not a statistical model: X has one row per asset, and y is not data (Schmelzer & Hastie, 2026, Section 4).

Only X⊤X and X⊤y matter, so any square root of Σ will do. If Σ is a sample covariance from a T×n return matrix R with n]]> T>n, the centred returns X=(R−𝟏r‾⊤)/T−1 work, with y from lstsq. For a factor model, stacking diag⁡(d)1/2 over diag⁡(δ)1/2U⊤ gives an (n+k)×n matrix with no factorisation at all, and y=(diag⁡(d)−1/2μ,0). Both reproduce the Cholesky path to rounding.

Parameters. λ: the tilt, or risk appetite. c: the gross-exposure cap, and κ: its multiplier, the LASSO penalty of Sections 5 and 6. t=𝟏⊤v=1/λ: the budget of the rescaled long-only problem, and ν: its multiplier, the LASSO penalty of Section 7.

With the gross exposure ‖w‖1 capped at c, minw12w⊤Σw−μ⊤ws.t.‖w‖1≤c(2) is, by (1), the LASSO in constrained form, the observation behind the sparse portfolios of Brodie et al. (2009). Its penalised form is min⁡β12‖y−Xβ‖22+κ‖β‖1, where κ≥0 is the multiplier of the cap and c=‖β(κ)‖1. So the LASSO path is the frontier of (2) (Schmelzer & Hastie, 2026, Theorem 1), and scikit-learn (Pedregosa et al., 2011) computes it:

The second line gives the same path from (Σ,μ) alone. In R the lars package (Hastie & Efron, 2022) traces it too:

It has no positivity constraint, so the long-only path of Section 7 needs scikit-learn. On the test problem the path has 21 columns: the empty portfolio at the start, 19 corners, each adding one asset, and the end. The path starts at w=0, which is optimal while κ≥max⁡j|μj|, and ends at κ=0, where the cap stops binding at w⋆=Σ−1μ with ‖w⋆‖1=7.765. That end maximises μ⊤w−12w⊤Σw, the second-order approximation to expected log growth, so it is the Kelly portfolio (Kelly, 1956). Since Σ−1μ also maximises the scale-free Sharpe ratio, it points towards the maximum-Sharpe portfolio. On the test problem the Sharpe ratio rises from corner to corner, from 0.539 at the first to μ⊤Σ−1μ=2.120 at the end, although nothing shown here says it must. Neither end is the minimum-variance portfolio, which needs the budget 𝟏⊤w=1 that (2) lacks.

A mandate usually fixes the leverage, say c=2, and varies risk appetite through a tilt 0]]> λ>0. Substituting w=λv in min⁡12w⊤Σw−λμ⊤w subject to ‖w‖1≤c gives (2) with cap c/λ. The same path therefore serves: a column β with t=‖β‖1, scaled to w=(c/t)β, is optimal at tilt λ=c/t.

At c=2 the columns cover tilts from 745.6 down to 0.2576. Below that the cap is slack and the solution λΣ−1μ shrinks to zero, so the path covers every tilt.

The classical frontier requires w≥0 and 𝟏⊤w=1. Substituting w=λv and using (1) turns the tilted problem into minv12‖Xv−y‖22s.t.𝟏⊤v=t,v≥0,t=1/λ,(3) with w=v/t (Schmelzer & Hastie, 2026, Proposition 3). For v≥0 the budget is ‖v‖1, so (3) is the nonnegative LASSO, whose penalty ν is the multiplier of the budget. lars_path(…, positive=True) traces it, and each column divided by its sum is a corner portfolio at tilt 1/𝟏⊤v.

The stop. Called on (X,y) the path runs from ν=max⁡jμj down to ν=0 and stops there, because a LASSO solver takes no negative penalty. (If every μj≤0 it returns only the origin.) On the test problem that gives 17 corners, down to tilt 0.1415. The stopping point v0=arg⁡min⁡v≥012v⊤Σv−μ⊤v is the end of Section 5 with long-only weights. Writing v=sw with 𝟏⊤w=1 and maximising over the scale s≥0 first leaves 12(μ⊤w)2/w⊤Σw, half the squared Sharpe ratio, so v0/𝟏⊤v0 is the long-only maximum-Sharpe portfolio, at tilt 0.1414. The frontier continues beyond it: the budget still binds while ν turns negative (Figure 2), which a constraint allows and a penalty does not (Schmelzer & Hastie, 2026, Section 3.4). The stop is a property of the penalised form that LASSO solvers use.

The shift. Completing the square once more moves the penalty into the response: 12‖Xv−y‖22+ν𝟏⊤v=12‖Xv−(y−νd)‖22+const,X⊤d=𝟏.(4) If the nonnegative LASSO runs on y−ν0d for some ν0<0, its penalty ν′≥0 acts as ν=ν0+ν′ on the original problem, and one path covers every ν≥ν0. For the Cholesky factor d=(X⊤)−1𝟏; for a tall X least squares returns the minimum-norm solution. lars_path reports ν′ divided by the number of rows, and it stops after 500 steps unless told otherwise, which a large problem needs:

Choosing ν0. Any ν0 below the last corner works, and the last corner is known in advance. Beyond it the portfolio holds the minimum-variance support S, which is the support of arg⁡min⁡u≥0‖Xu−d‖2 (Lawson & Hanson, 1974). There vS=a−νb with a=ΣSS−1μS and b=ΣSS−1𝟏, and the segment stays optimal while ν<ai/bi for 0]]> bi>0 and, for j∉S with 1]]> ΣjSb>1, while ν≤(μj−ΣjSa)/(1−ΣjSb). The smallest bound is the last corner νlast:

A fixed ν0 would not work, because νlast varies widely: it is −4.95 on the test problem, −11.9 on one of the models of Table 1, −0.190 on the stock data and −0.0118 on the portfolio data of Section 8, where μ is small. The margin δ in ν0=νlast−δmax⁡(|νlast|,‖μ‖∞) has to be large enough that the end of the path does not merge with the last corner, and small enough not to cost accuracy, which falls roughly in proportion to |ν0|. On the stock data δ=10−4 loses the last corner; from δ=10−2 to 1 all 116 are found with KKT residuals below 5×10−13, and at δ=100 the residual has grown to 3×10−11. On the portfolio data even δ=10−2 loses the last corner, and δ=1 finds all 12. The code takes δ=1. The minimum-variance portfolio itself is the limit ν→−∞; on the final segment it is wS∝ΣSS−1𝟏.

What ν means. By (4) the point with multiplier ν solves the same problem with μ replaced by μ−ν𝟏, so it is the long-only maximum-Sharpe portfolio at risk-free rate r=ν, Black’s zero-beta rate (Black, 1972), a classical result. What the LASSO adds is that the rate is the path’s own parameter, so for ν0<r<max⁡jμj the maximum-Sharpe portfolio is an interpolation between the two columns that bracket r:

Weights versus frontier. Between corners the weights are linear in the tilt λ (or, in Section 5, in the cap c) and the variance is quadratic, so each piece of the frontier is an arc. Traced by the tilt λ at fixed constraints (Sections 6 and 7), the frontier has no kinks, since its slope dE/dV=1/(2λ) varies continuously. The corners then show only in the weights (Figure 2). The long–short path of Section 5 is traced by the cap instead and does kink (Figure 1(a)).

Algorithm 1: the long-only frontier from lars_path.

Two kinds of evidence are reported. The first needs no second solver: each portfolio the path returns is checked against its own optimality conditions. For the cap with multiplier κ these are (μ−Σw)j=κsign(wj) on the support and |(μ−Σw)j|≤κ off it; for the long-only problem at tilt λ they are (Σw−λμ)j=γ on the support and ≥γ off it, with 𝟏⊤w=1 and w≥0. The KKT residual is the worst violation, divided by ‖μ‖∞ or by the size of the gradient. The second compares with baselines that are independent of the path. The long–short problems go to Clarabel, an interior-point solver, through cvxpy; the long-only problem goes to quadprog, the active-set method of Goldfarb and Idnani (1983).

Long–short. Every column has a KKT residual below 2.6×10−15, and below 2.9×10−15 once rescaled to fixed leverage. At each column’s cap Clarabel matches the path to 3.0×10−7 at the corners and 1.4×10−11 inside segments. The gap at the corners is the baseline’s, since interior-point methods are least accurate where the holdings change. At fixed leverage the figures are 6.2×10−6 and 1.9×10−11.

Long only. The shifted path finds 19 corners on the test problem, the 17 of a plain call and two more at tilts 0.1158 and 0.0128. They match the QP to 6.0×10−13, points inside segments to 7.9×10−14, the minimum-variance end to 1.0×10−16, and the maximum-Sharpe portfolio at r=0 to 3.4×10−15. The corners and the minimum-variance end have KKT residuals below 3.6×10−14. Table 1 repeats both checks on other sizes and seeds. Where the two disagree, at n=500, the residual shows that the gap of 6.7×10−11 is the QP’s. The number of corners need not equal the number of assets, because some assets leave and re-enter.

Portfolio returns. The daily value-weighted returns of the 100 portfolios that Fama and French form on size and book-to-market (French, n.d.), from January 2016 to December 2025, are free to download from their Data Library, and a script published with the code fetches them. One portfolio misses 250 days and is dropped, which leaves 99 portfolios over 2514 days. With the centred returns as X the last corner sits at νlast=−0.0118, eleven times max⁡j|μj| below zero. Algorithm 1 returns all 12 corners. They match the QP to 2.1×10−13 and have KKT residuals below 3.9×10−14, and the minimum-variance portfolio, which holds 7 of the portfolios, matches to 1.6×10−15. Diversified portfolios are highly correlated, so the frontier turns only 12 times and a grid of QPs is cheap here.

Stock returns. The second data set tests the method at scale. It is simulated, so it needs no download and every rerun reproduces it: daily returns of 500 stocks over 1250 days, about five years, from a five-factor model with a market factor of 1% daily volatility, four style factors of 0.5%, idiosyncratic volatility between 1% and 3%, and expected returns around five basis points a day. Unlike the test problem, μ and Σ are both estimated from the returns. With the centred returns as X the last corner sits at νlast=−0.190, about sixty times max⁡j|μj| below zero. Algorithm 1 returns all 116 corners in the time of about one QP solve, so a 100-point grid of QPs costs 75 to 95 times as much as the path and still misses the corners. Warm-starting narrows the gap without closing it: OSQP (Stellato et al., 2020), set up once so that its factorisation is reused, with each tilt changing only the linear term and each solve starting from the last, needs a sixth to a third of the cold grid’s time at tolerance 10−6 and agrees with the cold QP to 3.7×10−12 at every grid point. Absolute times depend on the machine and are not reported. Every corner has a KKT residual below 4.7×10−13 and matches its QP to 8.6×10−13, and the minimum-variance portfolio, which holds 63 stocks, matches to 5.8×10−16.

The path beats a grid of QP solves, cold- or warm-started, on accuracy, since it finds the corners exactly. On speed it wins at scale, on the 500 simulated stocks; on a problem as small as the Fama–French portfolios its lead shrinks to a factor of three or four. LARS is in R and scikit-learn, the positive LASSO only in scikit-learn, so corner portfolios need no portfolio software, and one call shows that the knots of a LASSO path and the turning points of a frontier are the same points. It is the wrong tool when Σ is singular, where the identity is not known to survive (Schmelzer & Hastie, 2026, Section 7), or when the portfolio needs more than one linear constraint. The LASSO that scikit-learn solves has exactly one besides the signs, ‖β‖1≤t: the gross-exposure cap of Sections 5 and 6, or, with positive=True, the budget 𝟏⊤w=1 of Section 7. The signs are either all free or all nonnegative. A dollar-neutral book adds the equality 𝟏⊤β=0, and a 130/30 book needs the budget and the gross cap at once. Path algorithms for a LASSO with general linear constraints exist (Gaines et al., 2018; James et al., 2020), but not in scikit-learn. The CLA takes such constraints and bounds on the weights directly, and cvxcla (Schmelzer, 2026) implements it. A risk budget w⊤Σw≤σ2 has no path of its own, but along each segment the variance is quadratic in the parameter, so the portfolio at a given σ comes from one scalar equation.

The numbers above are evidence for Theorem 1 and Proposition 3 of Schmelzer & Hastie (2026); the proofs are in that paper. Each check tests a prediction of one of the two results. Theorem 1 says the LASSO path is the frontier under a gross-exposure cap: every column meets the optimality conditions of its cap and matches Clarabel there. Proposition 3 says the nonnegative LASSO is the long-only frontier: every corner, and every point between corners, matches an active-set QP at the same tilt. Both make the frontier piecewise linear in its parameter, so a path finds its corners exactly where a grid of QP solves, cold- or warm-started, misses them. The checks were written by an author of Schmelzer & Hastie (2026), so they are not independent in the usual sense. The baseline solvers are, and the script and its tolerances are published so that anyone can rerun them. For practical use the note adds three details: the shift, a ν0 computed in advance, and a max_iter large enough for big problems.

The software is in the directory preprints/lasso/ of https://github.com/Jebel-Quant/lasso, under the MIT licence. python/make_figures.py regenerates every figure and number in the note; uv run python/make_figures.py test runs its checks. It is a single Python script that declares its own pinned dependencies, and python/make_figures.py.lock next to it fixes Python 3.12 and every package it pulls in, to the exact version and hash. The R snippet of Section 5 is R/long_short.R, with a check against lars_path.

The lockfile fixes the software, not the hardware. Residuals and gaps near 10−13 come out with different last digits on another CPU or BLAS build, so a rerun will not match the printed values digit for digit. The tests therefore check them against tolerances between 10−12 and 10−9. Costs are given only as ratios, which vary far less between machines than absolute times; uv run python/make_figures.py timings measures them.

The test problem, the factor models of Table 1 and the stock returns of Section 8 are simulated inside the script from fixed seeds, so they need no data. The portfolio returns of Section 8 come from Kenneth French’s Data Library (French, n.d.) and, being copyrighted, are not redistributed. python/fetch_french.py downloads them and writes data/french100_daily.csv. The note used the CRSP vintage of August 2026, SHA-256 98298ef6…3c43. The library rebuilds its history each month from CRSP, so a later download can differ where CRSP revises a return.

The author works at Jebel Quant Research, which hosts the code of this note, and maintains cvxcla, an open-source Python implementation of the Critical Line Algorithm. The note’s method needs neither: it runs on scikit-learn or R alone. Section 9 points to cvxcla for portfolios with more constraints, and the companion script checks its corners against it. The author declares no other competing interests.

I thank Trevor Hastie for many helpful discussions.