Tibshirani (1996) introduced the LASSO as least squares with a single constraint, a budget on the ℓ1 norm of the coefficients: minβ12‖y−Xβ‖22s.t.‖β‖1≤t,or equivalentlyminβ12‖y−Xβ‖22+λ‖β‖1. LARS (Efron et al., 2004) and the homotopy method (Osborne et al., 2000) compute the solution for every t, or every λ, at once. The solution is piecewise linear in the parameter, so the whole path is a finite list of knots. scikit-learn’s lars_path (Pedregosa et al., 2011) takes X, y and one option, positive, for nonnegative coefficients. There is no place for any other constraint.

Many regressions need one. The diabetes data that LARS was introduced with (Efron et al., 2004) illustrate what a constraint can do: n=442 patients, ten standardised baseline variables and, as the response, a measure of disease progression a year later. Six of the variables are blood serum measurements, and three of them are closely related measures of cholesterol: total cholesterol (s1), LDL (s2) and HDL (s3). Least squares plays them off against each other. It gives total cholesterol a coefficient of −792 and LDL one of 477: two large effects of opposite sign that mostly cancel. HDL gets 101, as if more of it made the disease progress faster. Low HDL is a risk factor for incident diabetes (Wilson et al., 2007); the response here is progression in patients who have the disease, so that finding suggests a negative sign but does not establish one. The LASSO path ends at the least-squares fit, so it gets there too. A cap on every coefficient, |βj|≤u, stops the offsetting. We take u=396.1, half the largest least-squares coefficient, a value chosen after seeing the fit. The example shows what a cap does to offsetting coefficients; it is not offered as a better model of the disease.

Figure 1 shows what the cap does. Without it the path passes the cap at ten of its 13 knots and ends with HDL positive. With it no coefficient passes the cap, and HDL stays negative along the whole path, although no sign is imposed. That does not hang on the choice of u: every whole-number cap up to 637 keeps HDL negative along the whole path, and only looser caps let it turn positive. That is a property of these data, not a finding about HDL. The capped path has 13 knots.

Both panels are exact paths. They come from the Critical Line Algorithm (CLA), which Markowitz (1956) wrote for portfolios, applied to one of the two encodings described below. The open-source package cvxcla (Schmelzer, 2026a) carries them out (Algorithm 1), and the right panel is one call:

The same call also takes signs (a bound of zero), equality rows a, b and inequality rows g, h, and picks the encoding that fits them.

What this note shows Schmelzer and Hastie (2026) prove that the CLA and the constrained LASSO (Gaines et al., 2018; James et al., 2020) trace the same curve; Table 1 gives the dictionary. Portfolio managers have always needed constraints, such as a budget, position limits and sector exposures, and Markowitz built them into the CLA from the start. So a CLA written for portfolios, with a thin layer that poses the regression as a portfolio, should give exact constrained-LASSO paths. This note shows that it does, or stops with an error where its arithmetic cannot be trusted, and checks every path against references that know nothing of portfolios. The layer is two encodings, Propositions 1 and 2. The propositions need nothing from Schmelzer & Hastie (2026) beyond the classical equivalence of the bound and penalty forms of the LASSO; that paper supplies the general identity of which they are instances. The checks also exposed two defects in the CLA that refused ordinary portfolio problems too, a tie for the largest expected return and a covariance of low rank. Both were fixed in cvxcla 2.6.0 (Schmelzer, 2026a). Drawing the hostile problems of Section 5.4 over more seeds exposed three more, on a design whose columns are nearly collinear: two in the check that a bound held along a segment is still optimal, which refused a correct path, and one in the plain LASSO homotopy, which lost the second of two events at the same λ. All three were fixed in 2.7.1, the release used here. Brodie et al. (2009) put an ℓ1 penalty on Markowitz portfolios to make them sparse, and a companion note (Schmelzer, 2026b) computes efficient frontiers with a LASSO solver. Both use regression to build portfolios. This note goes the other way. Section 2 recalls the CLA, Section 3 gives the two encodings, Section 4 says where the path starts and ends and collects them in Algorithm 1, Section 5 checks the paths, and Section 6 gives the limits.

The penalty form (Section 3.1) keeps λ as the parameter and takes bounds, equality rows Aβ=b and inequality rows Cβ≤h; it is the general form. The budget form (Section 3.2) keeps the ℓ1 budget, as Markowitz’s long-only, fully invested problem with a cash asset, and takes homogeneous constraints such as the zero sum 𝟏⊤β=0 of compositional data in one run.

Related work Exact paths of the constrained LASSO are not new. Gaines, Kim and Zhou (2018) derive a path algorithm from its optimality conditions that takes general linear rows. For Cβ=0 alone, the Python package c-lasso (Simpson et al., 2021) has a path algorithm with a small ridge term added. For zero sums on blocks of coefficients, the comlasso algorithm of Jeon et al. (2020) traces the exact path, also with n]]> p>n. None was derived with portfolios in mind, so Section 5 runs all three as independent checks. Hobson, Butcher and Lentati (2026) revisit Gaines et al. with CLASSO. The linear system of Gaines et al. is singular whenever a sign constraint binds on a zero coefficient, so CLASSO takes the direction from a small quadratic program instead. In the CLA a sign or a cap is a bound, not a row, so that singularity does not arise. CLASSO adds a ridge when n<p, and its code had not been released when we wrote, so we do not run it. The CLA is an active-set method of the same kind, written for portfolios and used here as released. With n]]> p>n the other path algorithms for general constraints add a ridge, which decides where their path ends; the CLA needs none (Section 4). Microbiome studies often have more taxa than samples, so this is the case a user of the zero-sum LASSO meets first. Table 6 collects what each accepts.

Notation The design is X∈ℝn×p, with n observations and p predictors, and the response is y∈ℝn. Write G=X⊤X and c=X⊤y. The constrained LASSO is Lλ:minβ12‖y−Xβ‖22+λ‖β‖1s.t.Aβ=b,Cβ≤h,l≤β≤u,(1) with A∈ℝm×p, C∈ℝk×p and lj≤0≤uj, infinite entries allowed, and a nonempty feasible set. A bound that excludes zero, such as βj≥ℓ with 0]]> ℓ>0, is written as the row −βj≤−ℓ. With no rows and infinite bounds it is Tibshirani’s LASSO. We assume, as (Schmelzer & Hastie, 2026) does, that Lλ has a unique minimiser β(λ) for every 0]]> λ>0. Without constraints this holds when the columns of X are in general position (R. J. Tibshirani, 2013), and with constraints when X has full column rank (Hobson et al., 2026, Theorem 6). For constrained problems with n]]> p>n we know of no such result. The checks of Section 5 test optimality, not uniqueness: where the minimiser is not unique, they confirm that the path is a path of minimisers.

The CLA starts with the portfolio of highest expected return and lowers the risk tolerance; between corners, the turning points or knots, the optimal portfolio moves along a straight line. Precisely, it solves the family of quadratic programs Pγ:minx12x⊤Σx−(q+γμ)⊤xs.t.Ax=b,Cx≤h,l≤x≤u,(2) for every γ from +∞ down to 0, with Σ≽0. Markowitz’s algorithm (Markowitz, 1956) handles general linear constraints; we write them as equality rows, inequality rows and bounds, the form cvxcla takes. Here x is the vector of holdings, Σ the covariance, μ the expected returns and γ the risk tolerance. The term q is a benchmark. With q=Σx‾ the objective is, up to a constant, the tracking variance against a portfolio x‾ less γμ⊤x: the same CLA after the bounds and right-hand side are shifted by x‾. With q=0 it is Markowitz’s problem.

Segments Write g=Σx−q−γμ+A⊤ν+C⊤η for the gradient of the Lagrangian. A point x with multipliers ν and η is optimal when gj=0 on the free coordinates ℱ={j:lj<xj<uj}, gj≥0 where xj=lj, and gj≤0 where xj=uj. In addition η≥0, with ηi=0 on every row that is slack, Cix<hi. Call the coordinates at a bound blocked, ℬ, and the rows held tight active, ℛ. An active row is held as an equality. In the system below it is stacked under A, with its right-hand side hi under b and its multiplier ηi under ν; the slack rows take no part. To keep the display short, A, b and ν stand for these stacks. With ℱ, ℬ and ℛ fixed, xℱ and ν solve the bordered system [ΣℱℱAℱ⊤Aℱ0][xℱν]=[qℱ−Σℱℬxℬb−Aℬxℬ]+γ[μℱ0],(3) so xℱ=α+γδ and ν=ν0+γν1 are affine in γ. The gradient on the blocked coordinates is affine too, gℬ=g0+γg1. One factorisation and two right-hand sides give the whole segment.

Events Lowering γ, the segment ends at the first of four events (Schmelzer & Hastie, 2026, Section 2.1): a free coordinate reaches a bound, a blocked coordinate’s gradient changes sign, a slack row becomes tight, or an active row’s multiplier falls to zero. Each is the root of an affine function of γ, such as γ=−g0j/g1j. The coordinate or row concerned changes sides, (3) is solved again, and the walk continues; with no event left, the last segment runs to γ=0.

The start As γ→∞ the linear term dominates, and the path starts at a vertex maximising μ⊤x over the feasible set. A linear program finds it. Suppose the maximiser is unique, and as many of its coordinates lie strictly inside their bounds as there are equality rows and rows tight at it. Then the bordered matrix in (3) is nonsingular and the walk can begin. This is the nondegenerate case; cvxcla declines a degenerate start.

The two encodings differ most at the ends of the path. A nondegenerate start lets the walk begin at once; a degenerate one needs a relaxation.

Nondegenerate starts In the penalty form without equality rows the starting vertex is z=0: all positions are closed, because each costs more than it can earn. The first event is the first entry, at γ=max⁡j|cj| over the allowed signs, which is LARS’s λmax. Rows Cβ≤h with 0]]> h>0 are slack at z=0, so they leave the start unchanged, and a row joins the active set when the path reaches it, like a bound. With equality rows, or a row with hr<0 that leaves z=0 infeasible, the start is the linear program min⁡𝟏⊤z over ASz=b, CSz≤h, 0≤z≤u‾: the point of smallest ℓ1 norm on the constraint set. For generic A and b≠0 it is a unique vertex with m nonzeros, and the path holds still there, δ=0, until a second coefficient enters. In general, every constrained LASSO path is constant from some λ0 on, at a least-squares fit over the feasible points of smallest ℓ1 norm, and λ0 takes the place of λmax (Schmelzer & Hastie, 2026, Proposition 3). That fit can take a quadratic program to find. Under the fully invested constraint 𝟏⊤β=1 of sparse portfolio regression (Brodie et al., 2009) every long-only β in the simplex has ‖β‖1=1, so the starting linear program is not unique; cvxcla starts on the tied face where its quadratic term is smallest, which is that fit.

In the budget form the start, at γ=∞ and t=0, is the linear program max⁡c⊤Sw over the simplex: put the whole budget on the best asset. Without equality rows that is the predictor most correlated with the response. It enters with the sign of its correlation and with λ=lim⁡η/γ=max⁡j|cj|, just as in LARS. Under 𝟏⊤β=0 it is one long and one short position of weight 12 each, the most and the least correlated predictors, entering together. That is why two coefficients leave zero at once in Figure 3. Both starts are generically unique and nondegenerate.

Degenerate starts With b=0 the penalty form’s starting vertex is z=0, with no free coordinates for 0]]> m>0 rows. This is a degenerate vertex: the multipliers at the start are not determined by the active set, and (3) is singular. For homogeneous equality rows with signs the budget form is the remedy, because rescaling to the simplex moves the start off the origin. It cannot take rows or caps, which move with the parameter once rescaled (Proposition 2). Caps or inequality rows under a zero sum therefore leave only the penalty form, which starts degenerate there. So do homogeneous rows ( h=0), such as the ordering constraints of a monotone fit: all are tight at β=0.

cvxcla resolves both by relaxation, an implementation device rather than part of the method. It traces the problem twice, with the homogeneous rows relaxed to hr=ε and 2ε and a zero sum to Aβ=εAd and 2εAd for a generic feasible point d. In release 2.7.1, ε is 10−6 times the scale ‖c‖∞/max⁡jGjj of a coefficient, then 10−7 and 10−8 times it if needed. Both runs start nondegenerate. The relaxation enters only the right-hand side of (3), so where the two runs pass through the same active sets their knots are affine in ε, and 2(λk,βk)(ε)−(λk,βk)(2ε) is the knot at ε=0. That condition cannot be checked in advance. cvxcla therefore returns the extrapolated path only if a linear program finds multipliers that satisfy the optimality conditions of (1) at every knot and segment midpoint, to 10−9 relative to ‖c‖∞. Otherwise it retries with the next ε and, after the last, declines. The extrapolation only proposes a path; the certificate is what guarantees the path returned. The paths it returns are checked again, like every other path, in Section 5.

The end of the path As λ→0+ the path ends at the least-squares fit of smallest ℓ1 norm under the constraints (Schmelzer & Hastie, 2026, Proposition 3). In the budget form this is where cash leaves its bound, its gradient η reaching zero (Figure 2(b)), and the run stops there. With n]]> p>n the end is an interpolating fit, and there that event wins a tie, since every correlation vanishes together with η. X⊤X is then singular, but the bordered system needs a positive definite Hessian only on the null space of the active rows, the standing assumption of Schmelzer & Hastie (2026), so the free set can outgrow the rank of X. The other path algorithms for general constraints add a ridge: 10−4 in Gaines et al. when n<p, 10−3 in c-lasso, and 10−4max⁡jGjj in CLASSO. At that ridge the authors of CLASSO report objectives up to 4×10−2, relative, above the unregularised ones (Hobson et al., 2026, Table 3). Each then traces a nearby problem whose path ends elsewhere.

Algorithm 1: the constrained LASSO path from a CLA.

cvxcla.Lasso(X, y, a=A, b=b, g=C, h=h, lower=l, upper=u) (release 2.7.1) carries out steps 1–5 and returns the knots. With no constraint at all it traces the plain LASSO by a homotopy instead.

Each check tests a prediction of Schmelzer & Hastie (2026). Their Lemma 1 makes Lλ and the CLA one parametric quadratic program, so the penalty form should return the knots of Lλ: LARS tests this knot by knot where it applies, and the interior-point solver and the optimality conditions everywhere. Their Theorem 1 and Corollary 1 give the bound form the same knots, so the budget form should return them too: comlasso and c-lasso test this on the zero sums.

When two columns nearly coincide and both become free, moving weight from one to the other barely changes the fit. Unless an active row forbids that move, (3) is then singular to working precision and cvxcla stops (Duplicate at 1.0×10−6, Table 4). This is the general-position assumption of Section 1, failing in floating point. Dropping or merging one of the two columns before tracing avoids it. A relaxation can also fail its certificate, when knots of the exact path lie closer together than the relaxation moves them; here none was declined. Finally, we do not prove that the walk terminates. The non-terminating examples of Hobson et al. (2026) need multipliers that are not unique, which a nonsingular (3) rules out, and every walk here ended.

When to use it cvxcla.Lasso is for LASSO paths under constraints lars_path does not take: caps, signs on some coefficients, equality and inequality rows and zero sums, also with n]]> p>n. It returns the knots at less cost than a grid of interior-point solves (Section 5.3). For the plain or positive LASSO, lars_path is enough. Two nearly identical columns should be merged first. Table 6 lists what each path algorithm accepts.

We do not compare run times with comlasso, the algorithm of Gaines et al. or c-lasso. None runs here as its authors would run it today: comlasso is R code built for R 3.2 and read under R 4, the algorithm of Gaines et al. is our port of Julia 0.6 code, and c-lasso returns a grid of its own with a ridge. A timing across R, Julia and Python would measure the languages and the ports as much as the algorithms. A user choosing among them should first ask which constraints each accepts, and then time them on their own problem.

The checks here support the identity of Schmelzer and Hastie (2026) wherever the encodings reach. On every problem, a CLA written for portfolios returns the exact knots, or stops with an error where its arithmetic cannot be trusted. With n]]> p>n the paths stay exact with no ridge, where the other path algorithms for general constraints trace a ridged problem that ends elsewhere.

The software is in preprints/constrained_lasso/ of https://github.com/Jebel-Quant/lasso, under the MIT licence. Each script has a lockfile that fixes Python 3.12 and every package by version and hash. python/make_figures.py computes every path with cvxcla.Lasso 2.7.1 (Schmelzer, 2026a), runs every check, and writes every figure, table and number the text quotes. python/classo_check.py runs c-lasso 1.0.11. R/comlasso_check.R runs comlasso 0.2 under R 4.6.1, locally and in CI. The package was built for R 3.2, and R 4 refuses to install a package built before R 4.0, so the script does not install it. It fetches the package from its authors’ repository at a pinned commit, checks its SHA-256, and reads its functions from the package’s serialized code with lazyLoad, unchanged. comlasso is plain R, with no compiled code, so nothing in it depends on the R 3 build; its one dependency, Rglpk, comes from a dated CRAN snapshot. julia/classopath.jl ports ConstrainedLasso.jl, written for Julia 0.6, to Julia 1.12, with each departure marked; none changes the algorithm. julia/gaines_check.jl runs it in a pinned environment. The sCD14 data are not redistributed: python/fetch_scd14.py downloads coda4microbiome 0.2.4 from CRAN or, should CRAN drop it, from a dated snapshot of Posit Package Manager. It checks the SHA-256 of the tarball, and that of the data file inside it, which is the same byte for byte in both. make figures runs all five, in CI as well.

Every random design is drawn inside python/make_figures.py from a seed recorded there: seed 7 for the problems of Table 2, seeds 7 to 9 for Table 3, and seeds 7 to 16 for Tables 4 and 5. On a fixed platform the discrete results reproduce exactly: the knot counts, which problems are declined, and whether each path passes the certificate. A test runs the problems of Tables 3 and 4 twice and checks that they do. Only residuals near rounding vary, and only in their last digits.

The lockfiles fix the software, not the hardware: those residuals also differ in the last digits on another CPU, so the tests use tolerances between 10−12 and 10−10, and costs are given only as ratios.

Competing interests The author works at Jebel Quant Research, which hosts the code, and maintains cvxcla, which computes every path. The checks are the author’s; the references they compare against are not. LARS, Clarabel, comlasso, ConstrainedLasso.jl and c-lasso were written by others, and the optimality conditions need no solver. There are no other competing interests.

Acknowledgements I thank Trevor Hastie for many helpful discussions.