Tutorial review pass: correctness fixes, notation, ch9 data, ch16 rewrite

Correctness:
- ch8: fix the DPP regularization path (loss and penalty were on separate
  variables, so every path coefficient came out zero); share one variable.
- ch13: fix the near-isotonic penalty sign (pos(diff) penalized upward
  steps and flattened to the mean; pos(-diff) penalizes downward steps).
- ch14: clear the fixed start before best_of so the random restarts run
  (a preset value(x) silently pinned them all to the same result).

Math and notation:
- ch4: add standard-form definitions for LP, QP, SOCP, SDP.
- ch5: normalize the elastic-net loss by 1/(2n) to match the code.
- ch6/ch7/ch8/ch10: use n (observations) / p (variables) consistently.
- ch15: define monomial and posynomial in the DGP intro.
- ch2/ch3: align exercise statements with their code and solutions.

Content:
- ch9: replace the arbitrary alphabetical stock subset with daily adjusted
  prices for the 12 largest US companies (Yahoo Finance, 2022-2024); the
  data is now our own, models cited to Markowitz and Rockafellar-Uryasev;
  drop all Riskfolio-Lib references and the bib entry.
- ch11: present the HiGHS/MIQP solver limitations as current, changeable
  behavior rather than permanent rules.
- ch16: rewrite as a participant-facing open session with honest
  expectations; drop internal planning notes.
- index: clarify the Render button note.

Author: bnaras

02-gentle-intro.qmd

@@ -314,16 +314,16 @@ value(beta)
 ```
 :::
 
-**Exercise 3 (⭐).** Constrain the first four coefficients to sum to at most zero,
-$\sum_{i=1}^{4}\beta_i \le 0$, using a matrix row rather than writing out four terms.
+**Exercise 3 (⭐).** Constrain the first four coefficients to sum to at least 4,
+$\sum_{i=1}^{4}\beta_i \ge 4$, using a matrix row rather than writing out four terms.
 
 ::: {.callout-tip collapse="true"}
 ## Solution
 Build a row vector that picks out $\beta_1,\ldots,\beta_4$:
 ```{r}
 #| label: ex-sum
 A <- matrix(c(rep(1, 4), rep(0, 6)), nrow = 1)
-sum_con <- Problem(obj, constraints = list(A %*% beta <= 0))
+sum_con <- Problem(obj, constraints = list(A %*% beta >= 4))
 psolve(sum_con)
 value(beta)
 ```

03-dcp.qmd

@@ -207,9 +207,10 @@ is_dcp(p)
 psolve(p)
 c(x = value(x), y = value(y))
 ```
-`-square(·)` is concave and the constraint is `affine == affine`, so the problem is
-`Maximize(concave)` subject to a legal constraint --- DCP, with optimum
-$x = y = 1/2$.
+`square` is convex, so `-square(x)` and `-square(y)` are each concave, and a **sum
+of concave expressions is concave** --- so the objective `-square(x) - square(y)` is
+concave. The constraint is `affine == affine`, so the problem is `Maximize(concave)`
+subject to a legal constraint --- DCP, with optimum $x = y = 1/2$.
 :::
 
 **Exercise 3 (⭐).** The expression `x^2 / y` (with `y > 0`) is convex --- the

04-problem-types.qmd

@@ -33,6 +33,16 @@ is expressible and which solvers apply.
 
 Linear objective, linear constraints. The workhorse of operations research.
 
+$$
+\begin{array}{ll}
+\text{minimize}   & c^\top x\\
+\text{subject to} & Gx \preceq h,\quad Ax = b,
+\end{array}
+$$
+
+with variable $x$ (length $n$); the data $c, G, h, A, b$ are constant and every
+expression is affine in $x$. ($\preceq$ is the componentwise $\le$ for vectors.)
+
 ```{r}
 #| label: lp
 x <- Variable(2)
@@ -47,6 +57,16 @@ value(x)
 A convex **quadratic** objective with linear constraints. Least squares (and ridge,
 and the Markowitz portfolio of @sec-portfolio) live here.
 
+$$
+\begin{array}{ll}
+\text{minimize}   & \frac{1}{2}\,x^\top P x + q^\top x\\
+\text{subject to} & Gx \preceq h,\quad Ax = b,
+\end{array}
+$$
+
+with $P \succeq 0$ (positive semidefinite) --- that condition is exactly what makes
+the objective convex. Taking $P = 0$ recovers an LP.
+
 ```{r}
 #| label: qp
 set.seed(1)
@@ -60,8 +80,20 @@ value(z)
 ## Second-order cone program (SOCP)
 
 Adds constraints involving the Euclidean norm --- "second-order cones." Anything with
-a `p_norm(., 2)`, `huber`, or robust-constraint flavor is typically an SOCP. Minimizing
-a norm subject to a budget is the canonical toy:
+a `p_norm(., 2)`, `huber`, or robust-constraint flavor is typically an SOCP.
+
+$$
+\begin{array}{ll}
+\text{minimize}   & f^\top x\\
+\text{subject to} & \| A_i x + b_i \|_2 \le c_i^\top x + d_i,\quad i = 1,\dots,m,\\
+                  & Fx = g.
+\end{array}
+$$
+
+Each "norm $\le$ affine" row is a *second-order cone* constraint --- it forces the
+pair $(A_i x + b_i,\; c_i^\top x + d_i)$ into the cone
+$\{(y, t) : \|y\|_2 \le t\}$. Minimizing a norm subject to a budget is the canonical
+toy:
 
 ```{r}
 #| label: socp
@@ -74,8 +106,20 @@ round(value(xs), 4)             # 1/3 each -> the min-norm point on the simplex
 
 The most general of the four: constraints that a **matrix is positive semidefinite**
 ($\succeq 0$), written with `%>>%`. Eigenvalue optimization, covariance/correlation
-problems, and relaxations of hard combinatorial problems are SDPs. Here we compute the
-largest eigenvalue of a matrix $M$ as $\min\{t : tI - M \succeq 0\}$:
+problems, and relaxations of hard combinatorial problems are SDPs.
+
+$$
+\begin{array}{ll}
+\text{minimize}   & c^\top x\\
+\text{subject to} & x_1 F_1 + \cdots + x_n F_n + G \;\succeq\; 0,\quad Ax = b,
+\end{array}
+$$
+
+where $F_1,\dots,F_n, G$ are symmetric matrices and $\succeq 0$ means positive
+semidefinite; that matrix inequality is a *linear matrix inequality* (LMI).
+Equivalently, the variable can itself be a symmetric matrix $X \succeq 0$. Here we
+compute the largest eigenvalue of a matrix $M$ as $\min\{t : tI - M \succeq 0\}$ (an
+LMI in the scalar $t$):
 
 ```{r}
 #| label: sdp

05-elastic-net.qmd

@@ -32,7 +32,7 @@ combines them:
 
 $$
 \underset{\beta}{\mbox{minimize}}\quad
-\frac{1}{2m}\|y - X\beta\|_2^2
+\frac{1}{2n}\|y - X\beta\|_2^2
 \;+\;\lambda\Big(\tfrac{1-\alpha}{2}\|\beta\|_2^2 + \alpha\|\beta\|_1\Big).
 $$
 

06-change-the-loss.qmd

@@ -45,12 +45,12 @@ responses** --- nasty outliers by construction.
 ```{r}
 #| label: huber-data
 set.seed(1289)
-m <- 450; M <- 1; pflip <- 0.10
+n <- 450; M <- 1; pflip <- 0.10
 beta_true <- 5
-X <- matrix(rnorm(m), ncol = 1)
+X <- matrix(rnorm(n), ncol = 1)
 y_true <- X * beta_true
-flip <- 2 * rbinom(m, 1, 1 - pflip) - 1     # -1 flips the sign
-y <- flip * y_true + rnorm(m)
+flip <- 2 * rbinom(n, 1, 1 - pflip) - 1     # -1 flips the sign
+y <- flip * y_true + rnorm(n)
 ```
 
 Now fit the *same* problem with two losses --- squared and Huber:
@@ -151,7 +151,7 @@ regression is for.
 
 **Exercise (⭐).** The Huber threshold $M$ interpolates between two losses. What does
 Huber regression become as $M \to 0$? As $M \to \infty$? Check the small-$M$ case
-against the LAD fit from @sec-gentle-intro.
+against LAD --- the loss you met in @sec-gentle-intro.
 
 ::: {.callout-tip collapse="true"}
 ## Solution
@@ -175,8 +175,6 @@ The two nearly coincide.
   quantiles, absolute → median.
 - Each is a **one-line change** to the objective --- the modeling vocabulary you are
   building transfers directly.
-- A kinked loss can trip a particular solver; naming a robust solver
-  (`solver = "CLARABEL"`) is sometimes the easiest fix.
 
 See [Huber](https://cvxr.rbind.io/examples/regression/huber-regression.html) and
 [Quantile](https://cvxr.rbind.io/examples/regression/quantile-regression.html).

07-logistic.qmd

@@ -27,7 +27,7 @@ log-likelihood
 
 $$
 \underset{\beta}{\mbox{maximize}}\quad
-\sum_{i=1}^m \Big[\, y_i\, x_i^\top\beta - \log\big(1 + e^{x_i^\top\beta}\big) \Big].
+\sum_{i=1}^n \Big[\, y_i\, x_i^\top\beta - \log\big(1 + e^{x_i^\top\beta}\big) \Big].
 $$
 
 The first term is linear; the second is a sum of $\log(1 + e^{z})$ terms.
@@ -58,12 +58,12 @@ $\sum_i \log(1+e^{x_i^\top\beta})$ as `sum(logistic(X %*% beta))`:
 ```{r}
 #| label: fit
 set.seed(42)
-m <- 500; n <- 8
-beta_true <- rnorm(n)
-X <- matrix(rnorm(m * n), m, n)
-y <- as.numeric(1 / (1 + exp(-X %*% beta_true)) > runif(m))   # 0/1 labels
+n <- 500; p <- 8
+beta_true <- rnorm(p)
+X <- matrix(rnorm(n * p), n, p)
+y <- as.numeric(1 / (1 + exp(-X %*% beta_true)) > runif(n))   # 0/1 labels
 
-beta <- Variable(n)
+beta <- Variable(p)
 loglik <- sum(y * (X %*% beta)) - sum(logistic(X %*% beta))
 prob <- Problem(Maximize(loglik))
 psolve(prob)

08-dpp.qmd

@@ -68,7 +68,7 @@ good <- Problem(Minimize(g * w), list(w == g * z, z >= 1))
 cat("Is DPP?", is_dpp(good), "\n")
 ```
 
-## The payoff: watch the compile time vanish
+## The payoff: watch the compile time drop
 
 Recall from @sec-gentle-intro that `verbose = TRUE` splits each solve into a
 **compile time** and a **solver time** in its summary. Parameters target the
@@ -79,9 +79,9 @@ a `Parameter`, and solve it the first time:
 #| label: verbose-first
 #| message: true
 set.seed(1)
-n <- 120; m <- 40
-A <- matrix(rnorm(n * m), n, m); b <- rnorm(n)
-x <- Variable(m)
+n <- 120; p <- 40
+A <- matrix(rnorm(n * p), n, p); b <- rnorm(n)
+x <- Variable(p)
 error <- sum_squares(A %*% x - b)
 
 gamma <- Parameter(nonneg = TRUE)
@@ -101,7 +101,7 @@ value(gamma) <- 0.7
 psolve(param_prob, verbose = TRUE)        # re-solve: compilation is cached
 ```
 
-The compile time has **collapsed** --- CVXR reused the cached parameter-to-data
+The compile time has **dropped** --- CVXR reused the cached parameter-to-data
 mapping and went straight to the solver. A freshly built problem, by contrast, pays
 the full compile *every* time.
 
@@ -122,7 +122,7 @@ bench::mark(
 ```
 
 On our machine the DPP re-solve is roughly **2–3× faster per solve** and allocates
-less memory --- precisely the compile time we just watched disappear. Over a sweep of
+less memory --- precisely the compile time we just watched drop. Over a sweep of
 $K$ values you save that difference $K$ times.
 
 ::: callout-note
@@ -144,11 +144,11 @@ re-solve --- the path looks identical, but only one compilation happens:
 #| label: dpp-path
 lambda_vals <- 10^seq(-3, 1, length.out = 30)
 lambda <- Parameter(nonneg = TRUE)
-beta <- Variable(m)
-path_prob <- Problem(Minimize(error + lambda * p_norm(beta, 1)))
+beta <- Variable(p)
+path_prob <- Problem(Minimize(sum_squares(A %*% beta - b) + lambda * p_norm(beta, 1)))
 
 betas <- sapply(lambda_vals, function(l) { value(lambda) <- l; psolve(path_prob); value(beta) })
-dim(betas)   # m coefficients x number of lambda values
+dim(betas)   # p coefficients x number of lambda values
 ```
 
 Whenever you plan to solve the *same shape* of problem many times --- a path, a
@@ -157,11 +157,11 @@ grid search, a simulation, a bootstrap --- reach for a `Parameter`.
 ## The other half of the solve: warm starts
 
 Recall that every solve splits into a **compile time** and a **solver time**. DPP
-attacks the *compile* time --- it reuses the canonicalized problem structure so we
+mitigates the *compile* time --- it reuses the canonicalized problem structure so we
 never re-stuff the matrices. But the solver still starts **cold** each time, refining
 an internal guess from scratch until it converges.
 
-A **warm start** attacks the *other* half. A numerical solver is iterative; if you
+A **warm start** addresses the *other* half. A numerical solver is iterative; if you
 hand it a starting point already near the answer, it converges in fewer iterations.
 In a sweep over a fine grid the solution at one $\lambda$ is an excellent guess for
 the next, so the previous answer is exactly the start point we want. In CVXR that is

09-portfolio.qmd

@@ -1,8 +1,8 @@
 # Portfolio Optimization {#sec-portfolio}
 
-<!-- LIVE. Mean-variance (Markowitz) efficient frontier + mean-CVaR, on a real
-     12-asset price subset bundled in data/stock_prices.csv. Example and data
-     adapted from Riskfolio-Lib Tutorial 1 (Dany Cajas). Originals: Markowitz
+<!-- LIVE. Mean-variance (Markowitz) efficient frontier + mean-CVaR, on daily
+     adjusted prices for the 12 largest U.S. companies by market cap (Yahoo
+     Finance, 2022-2024), bundled in data/stock_prices.csv. Models: Markowitz
      (1952) mean-variance; Rockafellar-Uryasev (2000) CVaR. Verified vs CVXR 1.9.1. -->
 
 ::: callout-note
@@ -13,12 +13,11 @@ Value-at-Risk (CVaR)** --- all from real return data.
 :::
 
 ::: callout-tip
-## Credits
-The example and the bundled price data are adapted from
-[**Riskfolio-Lib**](https://github.com/dcajasn/Riskfolio-Lib) (Dany Cajas) ---
-"Tutorial 1: Classic Mean-Risk Optimization" [@riskfolio], itself built on CVXPY. The
-underlying models are due to @Markowitz:1952 (mean-variance) and
-@RockafellarUryasev:2000 (CVaR).
+## Data and models
+The models are classics: mean-variance optimization is due to @Markowitz:1952 and the
+CVaR reformulation to @RockafellarUryasev:2000. The bundled price data are daily
+adjusted closing prices for the 12 largest U.S. companies by market capitalization
+(source: Yahoo Finance, 2022--2024).
 :::
 
 ```{r}
@@ -47,8 +46,9 @@ return; large $\gamma$ avoids risk.
 
 ## Real data
 
-We use ~3 years of daily prices for 12 well-known stocks (a subset of the Riskfolio-Lib
-dataset), and turn prices into simple returns, a mean vector, and a covariance matrix:
+We use ~3 years (2022--2024) of daily adjusted prices for the **12 largest U.S.
+companies by market capitalization**, and turn prices into simple returns, a mean
+vector, and a covariance matrix:
 
 ```{r}
 #| label: data
@@ -133,8 +133,8 @@ ggplot(comp, aes(gamma, weight, fill = asset)) +
 ```
 
 The left-most bar (greedy, low $\gamma$) leans on one or two names; as $\gamma$ grows the
-bars fragment into the full palette. That shift *is* the efficient frontier, seen from
-the portfolio's side.
+weight spreads across a broader, more defensive set of names. That shift *is* the
+efficient frontier, seen from the portfolio's side.
 
 ## A different risk measure: CVaR
 
@@ -238,6 +238,5 @@ The cap spreads weight off the assets that the unconstrained solution concentrat
 - Swapping variance for **CVaR** is just a new objective --- CVXR makes alternative risk
   measures, position limits, and policy constraints one-liners.
 
-For many more portfolio models (risk parity, Black-Litterman, worst-case, drawdown
-measures), see [Riskfolio-Lib](https://github.com/dcajasn/Riskfolio-Lib) and the
+For more portfolio models and risk measures, see the
 [CVXR portfolio example](https://cvxr.rbind.io/examples/finance/portfolio-optimization.html).

10-invcov.qmd

@@ -55,14 +55,14 @@ invert it to get the covariance $R$, and sample from $N(0, R)$:
 ```{r}
 #| label: data
 set.seed(1)
-n <- 10        # number of variables
-m <- 1000      # number of samples
+p <- 10        # number of variables
+n <- 1000      # number of samples
 
-A      <- rsparsematrix(n, n, 0.15, rand.x = rnorm)
-Strue  <- as.matrix(A %*% t(A) + 0.05 * diag(n))   # sparse, symmetric, positive definite
+A      <- rsparsematrix(p, p, 0.15, rand.x = rnorm)
+Strue  <- as.matrix(A %*% t(A) + 0.05 * diag(p))   # sparse, symmetric, positive definite
 R      <- solve(Strue)                              # the covariance to sample from
 
-x <- matrix(rnorm(m * n), m, n) %*% chol(R)         # rows are i.i.d. N(0, R)
+x <- matrix(rnorm(n * p), n, p) %*% chol(R)         # rows are i.i.d. N(0, R)
 Q <- cov(x)                                          # sample covariance
 
 sum(abs(Strue) > 1e-4)                               # how many true nonzeros (of 100)
@@ -76,7 +76,7 @@ each solve, zero out numerically negligible entries to read off the recovered pa
 ```{r}
 #| label: fit
 alphas <- c(10, 6, 4, 1)
-S      <- Variable(c(n, n), PSD = TRUE)
+S      <- Variable(c(p, p), PSD = TRUE)
 obj    <- Maximize(log_det(S) - matrix_trace(S %*% Q))
 
 S_est <- lapply(alphas, function(a) {
@@ -106,7 +106,7 @@ mask of the truth alongside each fit:
 #| fig-height: 2.4
 #| fig-cap: "Nonzero pattern (dark = nonzero) of the true precision matrix and the estimates. Smaller alpha -> sparser. Around alpha = 4 the estimate matches the truth's sparsity."
 mask_df <- function(M, lab) {
-  data.frame(i = rep(seq_len(n), n), j = rep(seq_len(n), each = n),
+  data.frame(i = rep(seq_len(p), p), j = rep(seq_len(p), each = p),
              nz = factor(as.integer(as.vector(M) != 0)), panel = lab)
 }
 panels <- rbind(

11-mip.qmd

@@ -114,14 +114,21 @@ a CRAN solver simply by writing the objective in a form SCIP accepts. SOC plus
 integers is SCIP's home turf; the second-order cone is doing the work the quadratic
 objective could not.
 
-::: callout-warning
-## Two traps worth remembering
-- **Never send an SOC-containing mixed-integer problem to HiGHS.** It does not error
-  --- it silently returns a *wrong* `infeasible`. SOC + integers needs **SCIP**.
-- **A quadratic objective with integers (MIQP)** routes through CVXR's QP path, which
-  only commercial solvers serve. On CRAN, **reformulate the quadratic as an SOC**
-  (above) and use SCIP --- same answer. (Commercial solvers can take the squared form
-  directly, if you have one.)
+::: callout-note
+## Two current limitations (both may change)
+These reflect the state of the tooling *today*, not permanent rules --- worth knowing
+now, but re-test rather than assume, since solvers and CVXR's routing keep evolving.
+
+- **HiGHS with an SOC inside a mixed-integer problem.** As of this writing, HiGHS does
+  not support a second-order cone in a mixed-integer model, and rather than erroring it
+  can silently return a *wrong* `infeasible` --- so for now, send SOC + integers to
+  **SCIP**. HiGHS is under active development, so this is the likelier of the two to
+  change; check before relying on it.
+- **MIQP routing.** A quadratic objective with integers currently travels through
+  CVXR's QP path, where only commercial solvers are registered. On CRAN today,
+  **reformulate the quadratic as an SOC** (above) and use SCIP --- same answer.
+  (Commercial solvers take the squared form directly.) This routing is a CVXR
+  implementation choice that could also change.
 :::
 
 ## Exercise
@@ -245,8 +252,8 @@ rules written as constraints. (Swap in any puzzle by editing the `0`-padded matr
 - **MI-SOCP** (a cone plus integers) runs on **SCIP**. An integer problem with a
   *quadratic* objective (MIQP) goes to a commercial solver through CVXR's QP path ---
   but **reformulate the quadratic as an SOC** and SCIP solves it on CRAN, same answer.
-- Match the solver to the problem --- and never trust an SOC sent to a pure-MILP
-  solver like HiGHS.
+- Match the solver to the problem --- today a pure-MILP solver like HiGHS can't handle
+  an SOC (and may not tell you), so send those to SCIP for now.
 - Some integer problems have **no objective at all**: logical puzzles like Sudoku are
   pure *feasibility* programs, where every rule is an "exactly one" sum of booleans.