jaddle 0.2.2__tar.gz → 0.2.3__tar.gz

{jaddle-0.2.2 → jaddle-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaddle
-Version: 0.2.2
+Version: 0.2.3
 Summary: First-order primal-dual solvers for large-scale linear and convex programs, written in JAX
 Author: Brendan van Rooyen
 License-Expression: MIT
@@ -115,7 +115,7 @@ differentiated with respect to the LP's data, and solves batch with `vmap`
 
 **Composable optimisation primitives.** The convex solver builds on
 [Optax](https://github.com/google-deepmind/optax). It uses Optax's projection
-operators, and in `alternating` mode it accepts any Optax gradient
+operators, and with `adaptive_eta=False` it accepts any Optax gradient
 transformation as the update rule. A new primal–dual variant is often only a
 few lines of code: for example, giving the primal player plain gradient descent
 and the dual player Nesterov momentum.
@@ -274,7 +274,9 @@ some refinements of our own.
 iteration the step `η` is checked against a local estimate of the interaction
 term `(Δy)ᵀ A (Δx)`. A step that overshoots is rejected and shrunk. An accepted
 step is advanced conservatively. The step size learned during a solve is
-carried across restarts.
+carried across restarts. `adaptive_eta=False` turns the line search off and
+holds `η` at `step_size` (plain PDHG; `step_size="auto"` picks a step that is
+stable for the scaled problem).
 
 **Primal weight.** The primal and dual step sizes are `η / k` and `η · k`. The
 primal weight `k` is initialised from the ratio `‖c‖ / ‖b‖`. At each restart it
@@ -326,6 +328,7 @@ the dual objective as in PDLP, so far-away finite bounds do not swamp the gap.
 | `restarts`, `epochs_per_restart` | `True`, `None` | Adaptive restarts and the length cap of a restart cycle (`None` = no cap). |
 | `restart_decay`, `necessary_decay` | `0.2`, `0.8` | Thresholds for the sufficient-progress and stalling restarts. |
 | `k_scale`, `k_theta`, `k_init` | `1e8`, `0.5`, `None` | Clamp band, smoothing and initial value for the primal weight. |
+| `adaptive_eta`, `step_size` | `True`, `1.0` | Line search on the step `η` (off: `η` stays fixed), and the starting `η` (`"auto"` = `0.99/‖[[A, b], [cᵀ, 0]]‖₂`). |
 | `diag_adapt`, `diag_theta`, `diag_clamp` | `True`, `0.5`, `10.0` | Per-coordinate diagonal step metric on top of the scaling, adapted at each restart (larger steps for steadily drifting coordinates, smaller for oscillating ones). |
 | `ruiz_iterations`, `pc_iterations` | `10`, `1` | Number of preconditioning sweeps. |
 | `initial_solution`, `initial_opt_state` | `None` | Warm start from a previous solve's `solution` and `opt_state`. |
@@ -348,36 +351,48 @@ the dual objective as in PDLP, so far-away finite bounds do not swamp the gap.
 
 ### Batched and differentiable solves
 
-`jl.make_solver(lp, **options)` turns `solve()` into a pure JAX function of
-the LP's numbers. It takes the same options and reproduces `solve()` exactly,
-but it has no logging, time limit or `vertex_bias`. The numbers travel as a
-`jl.LPValues` pytree: the cost, the stored nonzeros of `A_eq` and `A_ineq` on
-`lp`'s sparsity pattern, the right-hand sides and the bounds
-(`jaddle_lp.values()` extracts them, `jaddle_lp.with_values(v)` puts them
-back). The function can be jitted, batched with `jax.vmap` and differentiated:
+As in the convex front end, write a function `build_lp(params)` that returns
+an ordinary `jl.LP` (or `JaddleLP`) whose numbers depend on `params`, any
+pytree. `jl.make_solver(build_lp, **options)` turns `solve()` into a pure JAX
+function of `params`. It takes the same options and reproduces `solve()`
+exactly, but it has no logging, time limit or `vertex_bias`. The function
+can be jitted, batched with `jax.vmap` and differentiated:
 
 ```python
-values = jl.to_jaddle_sparse(lp).values()
-solve_fn = jl.make_solver(lp, max_epochs=1000)
-result = jax.jit(solve_fn)(values)       # SolveCoreResult: solution, converged, ...
+def build_lp(price):
+    return jl.LP(c=price, A_eq=A_eq, b_eq=b_eq, A_ineq=A_ineq, b_ineq=b_ineq,
+                 lower_bounds=lb, upper_bounds=ub)
 
-costs = values.c * (1 + 0.1 * jax.random.normal(key, (32,) + values.c.shape))
-batch = jl.solve_batch(lp, values._replace(c=costs))   # 32 solves at once
+solve_fn = jax.jit(jl.make_solver(build_lp, max_epochs=1000))
+result = solve_fn(price)                 # SolveCoreResult: solution, converged, ...
+batch = jax.vmap(solve_fn)(prices)       # many LPs at once
 ```
 
-In a batch the cost, right-hand sides, bounds and matrix values can all vary;
-any field without a batch axis is shared. Each member is scaled as `solve()`
-would scale it, and finished members wait for the slowest. Members are not
-bit-identical to separate solves, because XLA rounds batched reductions
-slightly differently, but each certifies to the requested tolerance.
-
-Three functions differentiate through a solve:
+The LPs of one function share a sparsity pattern, which is read from whatever
+does not depend on `params` (`build_lp` runs under
+`jax.ensure_compile_time_eval`, so this holds under `jit` too). SciPy matrices
+and dense matrices that don't depend on `params` keep their nonzeros. A dense
+matrix that does depend on them stores every entry. To reuse a `JaddleLP`'s
+pattern with new numbers, `jl.make_solver(jaddle_lp.with_values)` takes a
+`jl.LPValues` pytree as `params`: the cost, the stored nonzeros of `A_eq` and
+`A_ineq`, the right-hand sides and the bounds (`jaddle_lp.values()` extracts
+them).
+
+In a batch the cost, right-hand sides, bounds and matrix values can all vary.
+`jl.solve_batch(build_lp, params, in_axes=0)` is the jitted `vmap`. Each
+member is scaled as `solve()` would scale it, and finished members wait for
+the slowest. Members are not bit-identical to separate solves, because XLA
+rounds batched reductions slightly differently, but each certifies to the
+requested tolerance.
+
+Three functions differentiate through a solve. Each takes `build_lp` and
+carries its gradient back through it to `params`:
 
 | Function | Differentiates | How |
 |---|---|---|
 | `jl.make_optimal_value` | the optimal value `z*` w.r.t. every number | envelope theorem: `∂z*/∂c = x*`, `∂z*/∂b = −y*`, `∂z*/∂A_ij = y*_i x*_j`, and the reduced costs for the bounds |
 | `jl.make_solution` | `x*` w.r.t. `b`, `A` and the bounds | implicit differentiation of the active constraints at a nondegenerate vertex (raises an error elsewhere) |
-| `jl.make_perturbed_solution` | a smoothed `x*` w.r.t. `c` | perturbed optimizer: averages solves at `c + σZ`, batched |
+| `jl.make_perturbed_solution` | a smoothed `x*` w.r.t. `c` | perturbed optimizer: averages solves at `c + σZ`, batched; `x_fn(params, key)` |
 
 An LP's solution is piecewise constant in its cost, so `dx*/dc` is zero
 almost everywhere. That's why the smoothed, perturbed version exists for
@@ -431,6 +446,16 @@ tests.
   dual_gap_tolerance=1e-4`: on stp3d (float64) that certifies in 24 s, where a
   plain solve is still at PFR 5e-6 after 150 s.
   `jl.solve_with_presolve(model, polish=True)` uses it for the reduced LP.
+- **Iterative refinement.** `jl.solve_with_refinement` is `jl.solve` with
+  iterative refinement (Gleixner, Steffy & Wolter, 2016). A loose first solve
+  is followed by rounds of correction LPs: the same problem shifted to the
+  current point, with the residuals scaled up to O(1). Each correction
+  restarts the solver on a well-scaled problem in place of a long tail. Unlike
+  polishing, it tightens the gap along with feasibility: on stp3d (float64,
+  `tol=1e-8, dual_gap_tolerance=1e-4`) one round certified in about 94 s,
+  with the gap at 9.7e-9. `result["refinement"]` records the rounds. For
+  presolved models use
+  `jl.solve_with_presolve(model, reduced_solver=jl.solve_with_refinement)`.
 - **Infeasibility detection.** `jl.detect_infeasibility` classifies an LP as
   `"primal_infeasible"`, `"dual_infeasible"` (unbounded if feasible),
   `"optimal"` or `"undetermined"` the PDLP way: diverging iterates give a
@@ -440,6 +465,67 @@ tests.
   coefficient ranges, which is the first thing to check when an instance
   misbehaves.
 
+### Conic programs
+
+The same solver handles second-order, positive semidefinite and exponential
+cones. Pass `cones=jl.Cones(soc=..., psd=..., exp=...)` to `jl.LP` and the
+last variables of `x` are constrained to cones, in the style of SCS's cone
+dimensions:
+
+```
+minimise    cᵀx
+subject to  A_eq x = b_eq,  A_ineq x <= b_ineq,  l <= x <= u   (linear variables)
+            x[K₁] ∈ K₁, x[K₂] ∈ K₂, ...                         (the tail of x)
+```
+
+With `n` variables and `jl.Cones(soc=(3, 5), psd=(4,), exp=2)`, the first
+`n − 24` are ordinary linear variables, the next 3 lie in a second-order cone
+`{(t, z) : ‖z‖ ≤ t}`, the next 5 in another, the next 10 hold a 4 × 4 PSD
+matrix in `svec` form (its upper triangle row by row, off-diagonals times √2;
+`jaddle.cones.svec` and `smat` convert), and the last 6 are two exponential
+cones `closure{(x, y, z) : y·exp(x/y) ≤ z, y > 0}`. Cone variables must be
+unbounded. A conic constraint `b − Ax ∈ K` becomes `Ax + s = b` with slack
+variables `s` in the cone.
+
+```python
+import numpy as np
+import scipy.sparse as sp
+import jaddle.jaddle_linear as jl
+
+# minimise cᵀz subject to ‖z‖ <= 1, as (t, z) in a second-order cone, t = 1
+c = np.array([1.0, -2.0, 2.0])
+n = 1 + c.size
+lp = jl.LP(
+    c=np.r_[0.0, c],
+    A_eq=sp.csc_matrix(np.eye(1, n)), b_eq=np.ones(1),
+    A_ineq=sp.csc_matrix((0, n)), b_ineq=np.zeros(0),
+    lower_bounds=np.full(n, -np.inf), upper_bounds=np.full(n, np.inf),
+    cones=jl.Cones(soc=(n,)),
+)
+z = jl.solve(lp)["solution"].primal[1:]   # -c / ‖c‖
+```
+
+Each step projects the cone variables onto their cones instead of onto a box:
+a closed form for second-order cones, one batched eigendecomposition per PSD
+size, and for exponential cones Friberg's univariate root search (as in SCS
+and Clarabel). The dual condition on a cone block is that its reduced cost
+lies in the dual cone `K*`, and the certificate measures dual infeasibility as
+the reduced cost's distance to `K*`, computed from the projection onto `K` as
+`−Π_K(−r)`. (The second-order and PSD cones are self-dual; the exponential
+cone is not.) The exponential cone's projection is built for float64. It is
+also the expensive part of an exponential-cone solve: on GPU it runs as a
+sequence of small kernels each iteration, so such problems are slower per
+iteration than SOC or PSD ones. Scaling, the
+diagonal metric and restarts work as for an LP, with column scales tied to one
+value per cone block. `jl.solve`, `make_solver`, `solve_batch` and
+`make_optimal_value` (differentiable optimal values) all take conic problems;
+presolve, crossover, polishing, iterative refinement, infeasibility
+detection and `make_solution` do not yet, and raise `NotImplementedError`.
+CVXPY problems with
+second-order, PSD and exponential constraints go through
+`jcv.JaddleConicSolver` (see
+[Modelling with CVXPY](#modelling-with-cvxpy)).
+
 ## The convex programming solver
 
 ### Problem form
@@ -467,24 +553,44 @@ automatic differentiation. No derivatives are required from the user.
 
 | Mode | Gradient evaluations per iteration | Description |
 |---|---|---|
-| `"alternating"` (default) | 1 | Primal step, then a dual step at the new primal point. The update rule is a user-supplied Optax optimiser. |
+| `"alternating"` (default) | 1 | Primal step, then a dual step at the new primal point: PDHG without the extrapolation. With `adaptive_eta=False` the update rule is a user-supplied Optax optimiser. Best used with restarts. |
 | `"extragradient"` | 2 | Korpelevich extragradient: a look-ahead step followed by a corrector step. Contractive for monotone problems. |
-| `"forward_reflected"` | 1 | Malitsky–Tam forward-reflected-backward: one gradient per iteration plus a reflection term built from the previous gradient. Requires the adaptive step. |
+| `"pdhg"` | 1 | PDHG as in the LP solver: a primal step, then a dual step that reads the extrapolated constraint values `2g(x⁺) − g(x)`. One gradient plus one constraint evaluation per iteration. Requires the adaptive step. |
 
-**Adaptive step size.** With `adaptive_eta="auto"` (the default), the
-extragradient and forward-reflected schemes use a Malitsky–Tam line search
-based on a local Lipschitz estimate. The two gradient evaluations that
+**Adaptive step size.** With `adaptive_eta=True` (the default, as in the LP
+solver), every scheme uses a Malitsky–Tam line search, started from
+`step_size` and based on a local Lipschitz estimate. The two gradient evaluations that
 extragradient already performs give an estimate of the local Lipschitz
-constant at no extra cost. The step is accepted while it remains within the
-admissible bound, and is rejected and shrunk otherwise. The learned step is
-carried across restarts.
+constant at no extra cost. PDHG and alternating get their estimate from
+consecutive iterations, so they check each step one iteration late and undo
+it if it overshot. The
+step is accepted while it remains within the admissible bound, and is rejected
+and shrunk otherwise. The learned step is carried across restarts.
 
 **Primal weight.** As in the LP solver, a primal weight `k` balances the primal
 and dual step sizes. It is initialised from the gradient of the objective and
 the constraint values at the origin, rebalanced at each restart, and clamped
-to `[1/k_scale, k_scale]` (default `k_scale = 10`).
-
-**Custom optimisers.** In `alternating` mode, `optimiser` accepts any Optax
+to `[1/k_scale, k_scale]` (default `k_scale = 100`; the LP solver's `1e8`
+let `k` swing far enough to collapse the adaptive step on some problems). It
+starts at 1 when the objective gradient or the constraint values at the origin
+are zero.
+
+**Diagonal metric.** As in the LP solver, `diag_adapt=True` (the default)
+adapts a per-coordinate step metric at each restart: larger steps for
+steadily drifting coordinates, smaller for oscillating ones. It applies to all
+three schemes with the adaptive step, and has no effect without restarts or
+with a custom optimiser.
+
+**Gradient scaling.** The solver sees a problem only through its functions,
+so it cannot equilibrate a matrix. Instead, `gradient_scaling=True` (the
+default) rescales the objective and each constraint row by the size of its
+gradient at the start point, as IPOPT does. This fixes objectives and rows in
+mismatched units, but not variables in mismatched units. The convergence test
+and the returned duals stay in the problem's own units.
+`jc.quadratic_program` scales its matrices itself, so it turns gradient
+scaling off unless asked.
+
+**Custom optimisers.** With `adaptive_eta=False`, `optimiser` accepts any Optax
 `GradientTransformation`. It is applied separately to the primal and dual
 players through `jaddle_optimisers.create_saddle_optimiser`. Ready-made
 choices include `jo.gd`, `jo.optimistic_gd`, `jo.optimistic_adadelta` and
@@ -495,7 +601,7 @@ optional `weight_function`) is on by default. As in the LP solver,
 `report_best=True` (the default) tests convergence on, and returns, whichever
 of the average and the last iterate has the lower KKT merit each epoch, so
 averaging never holds back a last iterate that is already converging. Adaptive
-restarts (`restarts=True`) are available but off by default.
+restarts (`restarts=True`) are on by default, as in the LP solver.
 
 **Termination.** The solver stops when all three of the following fall below
 their tolerances:
@@ -511,12 +617,14 @@ their tolerances:
 | Argument | Default | Purpose |
 |---|---|---|
 | `update_mode` | `"alternating"` | Iteration scheme (see above). |
-| `adaptive_eta` | `"auto"` | Adaptive line-searched step. Pass a float to set the seed, or `None` to use the optimiser's fixed learning rate. |
-| `optimiser` | `None` | Optax optimiser for `alternating` mode. When `None`, gradient descent with learning rate 0.5 is used. |
-| `iterations_per_epoch` | `1000` | Iterations per compiled epoch. |
+| `adaptive_eta`, `step_size` | `True`, `1.0` | Line search on the step `η`, and the starting `η`. With `adaptive_eta=False` the optimiser's fixed step is used instead. |
+| `optimiser` | `None` | Optax optimiser for the fixed step (`adaptive_eta=False`). When `None`, gradient descent with learning rate `step_size` is used. |
+| `iterations_per_epoch` | `256` | Iterations per compiled epoch. |
 | `max_epochs`, `max_seconds` | `None` | Iteration and wall-clock budgets. |
-| `k_scale`, `k_theta`, `k_init` | `10.0`, `0.5`, `None` | Primal weight controls. `k_scale=None` disables the primal weight. |
-| `restarts`, `epochs_per_restart` | `False`, `None` | Adaptive restarts (`epochs_per_restart=None` = no cycle cap). |
+| `k_scale`, `k_theta`, `k_init` | `100.0`, `0.5`, `None` | Primal weight controls. `k_scale=None` disables the primal weight. |
+| `restarts`, `epochs_per_restart` | `True`, `None` | Adaptive restarts (`epochs_per_restart=None` = no cycle cap). |
+| `diag_adapt`, `diag_theta`, `diag_clamp` | `True`, `0.5`, `10.0` | Per-coordinate diagonal step metric, adapted at each restart. |
+| `gradient_scaling` | `True` | Rescale the objective and constraint rows by their gradients at the start point. |
 | `initial_solution`, `initial_opt_state` | `None` | Warm start. |
 
 `solve` returns a dictionary containing `solution` (a `SaddleState`),
@@ -611,8 +719,8 @@ argument, a function of the solver state that returns the three quantities
 ## Modelling with CVXPY
 
 [CVXPY](https://www.cvxpy.org/) can serve as the modelling language
-(`pip install "jaddle[cvxpy]"`). `jaddle.jaddle_cvxpy` offers two routes, and
-both return results the CVXPY way: `problem.status`, `problem.value`,
+(`pip install "jaddle[cvxpy]"`). `jaddle.jaddle_cvxpy` offers three routes, and
+all return results the CVXPY way: `problem.status`, `problem.value`,
 `var.value`, each constraint's `dual_value`, and Jaddle's full result in
 `problem.solver_stats.extra_stats`.
 
@@ -626,6 +734,10 @@ w = cp.Variable(p)
 lasso = cp.Problem(cp.Minimize(cp.sum_squares(X @ w - y) + cp.norm1(w)))
 lasso.solve(solver=jcv.JaddleSolver(), tol=1e-6)
 
+# Second-order and PSD cones: Jaddle as a CVXPY conic solver.
+risk_limited = cp.Problem(cp.Maximize(mu @ w), [cp.sum(w) == 1, cp.norm(F.T @ w) <= 0.2])
+risk_limited.solve(solver=jcv.JaddleConicSolver(), tol=1e-6)
+
 # Any other DCP problem: compiled to a JaddleCP.
 logistic = cp.Problem(cp.Minimize(cp.sum(cp.logistic(-cp.multiply(labels, X @ w)))))
 jcv.solve(logistic, tol=1e-6)
@@ -640,18 +752,46 @@ tolerance on the original problem is reported as `"optimal_inaccurate"`.
 [`examples/lp/cvxpy_transport.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/lp/cvxpy_transport.py)
 is a small worked LP.
 
+**`JaddleConicSolver`** is a CVXPY conic solver for problems CVXPY can put in
+the form `min cᵀx  s.t.  Ax + s = b`, with `s` in a product of zero,
+nonnegative, second-order, PSD and exponential cones. It solves them with
+`jl.solve` on cone-constrained variables (see [Conic programs](#conic-programs));
+there is no presolve. When a cone constraint is on a variable itself, such
+as `X >> 0` for a variable `X`, the cone goes on that variable directly
+rather than on a copy tied to it by equality rows: on a 200-node Max-Cut SDP
+that cut the iterations threefold (`cone_substitution=False` turns it off).
+Power cones are not supported. Exponential cones bring
+in `log`, `log_det`, `log1p`, `rel_entr` and `kl_div`, which the compiled
+route below cannot take, alongside `exp`, `log_sum_exp`, `logistic` and
+`entr`.
+[`examples/conic/cvxpy_portfolio.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/conic/cvxpy_portfolio.py)
+traces a risk-limited portfolio's efficient frontier, and
+[`examples/conic/cvxpy_maxcut.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/conic/cvxpy_maxcut.py)
+solves the Goemans–Williamson Max-Cut SDP and rounds it to a cut, and
+[`examples/conic/cvxpy_kelly.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/conic/cvxpy_kelly.py)
+finds log-optimal (Kelly) portfolios, one exponential cone per scenario.
+
 **`jcv.solve`** handles the rest. For a general convex problem CVXPY's own
-reductions produce cones (exponential, second-order, PSD), and Jaddle has no
-cone projections. The cone form is also a poor fit for a first-order method:
+reductions produce cones, and the cone form is often a poor fit for a
+first-order method:
 on the L1-logistic regression in
 [`examples/cp/cvxpy_lasso.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/cp/cvxpy_lasso.py) it has 701
 variables, 1500 rows and 400 exponential cones. `jcv.compile_problem` instead
 walks the expression tree and builds a `JaddleCP` of JAX functions, with 101
-variables and 100 linear rows for that problem:
+variables and 100 linear rows for that problem.
+[`examples/cp/cvxpy_robust_kalman.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/cp/cvxpy_robust_kalman.py)
+compiles another such problem: a Kalman smoother with `huber(norm(v[t]))` on the measurement
+noise, which CVXPY would turn into second-order cones. The compiled route
+handles these atoms as follows:
 
 - smooth atoms stay smooth: `logistic`, `log_sum_exp`, `exp`, `huber`,
   `sum_squares`, `quad_form`, `quad_over_lin` with a constant denominator,
   even powers, and p-norms with p ≥ 1;
+- `entr` is continued below `jcv.ENTR_FLOOR` (1e-8) by its tangent line, so
+  iterates outside its domain see a finite value and gradient. This is exact
+  when the solution keeps the argument above the floor.
+  [`examples/cp/cvxpy_channel_capacity.py`](https://github.com/BrendanVR/Jaddle/blob/main/examples/cp/cvxpy_channel_capacity.py)
+  uses it to compute a channel's capacity;
 - piecewise-linear atoms (`abs`, `maximum`, `max`, `norm1`, `norm_inf`, and
   their concave mirrors `minimum` and `min`; `pos` and `neg` are written with
   these) become epigraph variables with one linear row per piece. This is
@@ -661,9 +801,10 @@ variables and 100 linear rows for that problem:
   costs no dual. The bound constraints' duals are recovered from the reduced
   gradient.
 
-Atoms with a restricted domain (`log`, `sqrt`, `entr`, ...) and second-order
-or PSD constraints raise `NotImplementedError`: Jaddle keeps its iterates
-inside the box only, so they would leave the domain. A problem that CVXPY can
+Other atoms with a restricted domain (`log`, `sqrt`, ...) and second-order
+or PSD constraints raise `NotImplementedError` on this route: the convex
+solver keeps its iterates inside the box only, so they would leave the domain.
+Second-order and PSD constraints go to `JaddleConicSolver` instead. A problem that CVXPY can
 put in QP form goes to `JaddleSolver` unless `qp_route=False`, so it gets
 presolve or KKT scaling. The compiled problem is solved by `jc.solve` with
 adaptive extragradient, restarts and gradient scaling (`jcv.COMPILED_DEFAULTS`).
@@ -695,30 +836,32 @@ recompilation.
 Jaddle's LP solver is evaluated on the LP relaxations of the 383 MIPLIB 2017
 instances used in the PDLP papers (100k–10M nonzeros). The run below used
 default solver settings in float64, HiGHS presolve, a relative tolerance of
-`1e-4` and a 600-second limit per instance, on one NVIDIA GeForce RTX 5070 Ti
+`1e-4` and a 3600-second limit per instance, on one NVIDIA GeForce RTX 5070 Ti
 Laptop GPU.
 
 | Outcome | Instances |
 |---|---|
-| Certified optimal on the HiGHS-presolved LP | **380 / 383** (one settled by presolve itself) |
-| Certified optimal on the original LP, after HiGHS postsolve | **291 / 383** |
-| Time limit reached | 3 |
+| Certified optimal on the HiGHS-presolved LP | **382 / 383** (one settled by presolve itself) |
+| Certified optimal on the original LP, after HiGHS postsolve | **297 / 383** |
+| Time limit reached | 1 (hgms62) |
 
 The two certificates differ because postsolve can enlarge a first-order
 solution's small dual errors, and because presolve can rescale a problem
 drastically, which changes what a relative tolerance means (see
-*Presolve and postsolve* above). `jl.solve_with_polishing` and
-`jl.crossover` can tighten a postsolved point when the original certificate
+*Presolve and postsolve* above). `jl.solve_with_polishing`,
+`jl.solve_with_refinement` and `jl.crossover` can tighten a postsolved point when the original certificate
 matters.
 
+Convergence on hgms62 can be recovered by altering the solvers default settings, in particular greatly increasing `diag_clamp` which alters the maximum amount of adaptive diagonal scaling used by the solver.
+
 Shifted geometric means of the solve time (shift 10 s, unsolved instances
-counted at the 600-second limit, as in the PDLP papers):
+counted at the 3600-second limit, as in the PDLP papers):
 
 | Time measured | SGM10 |
 |---|---|
-| Iteration loop, including the first-epoch compile (`solve_seconds`) | 7.04 s |
-| Iteration loop with the compile amortised out (`corrected_seconds`) | 4.62 s |
-| Wall clock, including presolve, scaling and setup | 9.81 s |
+| Iteration loop, including the first-epoch compile (`solve_seconds`) | 6.86 s |
+| Iteration loop with the compile amortised out (`corrected_seconds`) | 4.72 s |
+| Wall clock, including presolve, scaling and setup | 9.56 s |
 
 The benchmark harnesses, instance diagnostics and instructions for reproducing
 these results are described in [`benchmarks/README.md`](https://github.com/BrendanVR/Jaddle/blob/main/benchmarks/README.md).
@@ -729,12 +872,13 @@ these results are described in [`benchmarks/README.md`](https://github.com/Brend
 |---|---|
 | [`jaddle/jaddle_linear.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/jaddle_linear.py) | LP solver, scaling, certification and polishing |
 | [`jaddle/jaddle_convex.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/jaddle_convex.py) | Convex solver |
+| [`jaddle/cones.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/cones.py) | Second-order and PSD cones for the LP solver |
 | [`jaddle/jaddle_cvxpy.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/jaddle_cvxpy.py) | CVXPY front end |
 | [`jaddle/jaddle_basic_types.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/jaddle_basic_types.py) | `SaddleState`, `JaddleCP`, `LP` and `JaddleLP` |
 | [`jaddle/jaddle_optimisers.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/jaddle_optimisers.py) | Precision profiles and Optax saddle-point optimisers |
 | [`jaddle/presolve.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/presolve.py) | Defined-variable elimination and postsolve |
 | [`jaddle/highs_helpers.py`](https://github.com/BrendanVR/Jaddle/blob/main/jaddle/highs_helpers.py) | HiGHS converters and presolve interface |
-| [`examples/`](https://github.com/BrendanVR/Jaddle/blob/main/examples/README.md) | Worked LP and convex examples |
+| [`examples/`](https://github.com/BrendanVR/Jaddle/blob/main/examples/README.md) | Worked LP, conic and convex examples |
 | [`benchmarks/`](https://github.com/BrendanVR/Jaddle/blob/main/benchmarks/README.md) | MIPLIB and convex benchmark harnesses |
 | [`tests/`](https://github.com/BrendanVR/Jaddle/tree/main/tests) | Test suite (`pytest`) |
 | [`CHANGELOG.md`](https://github.com/BrendanVR/Jaddle/blob/main/CHANGELOG.md) | Changes in each release |